@mtcute/core 0.17.0 → 0.18.0-rc.5

package/highlevel/types/peers/user.js

@@ -0,0 +1,456 @@
+import { MtArgumentError } from "../../../types/errors.js";
+import { assertTypeIs } from "../../../utils/type-assertions.js";
+import { memoizeGetters } from "../../utils/memoize.js";
+import { MessageEntity as MessageEntity$2 } from "../messages/message-entity.js";
+import { EmojiStatus as EmojiStatus$1 } from "../reactions/emoji-status.js";
+import { ChatColors as ChatColors$1 } from "./chat-colors.js";
+import { ChatPhoto as ChatPhoto$2 } from "./chat-photo.js";
+import { makeInspectable } from "../../utils/inspectable.js";
+class User {
+  type = "user";
+  /**
+   * Underlying raw TL object
+   */
+  raw;
+  constructor(user) {
+    assertTypeIs("User#init", user, "user");
+    this.raw = user;
+  }
+  /** Unique identifier for this user or bot */
+  get id() {
+    return this.raw.id;
+  }
+  /**
+   * Whether this user's information is incomplete.
+   *
+   * This usually only happens in large chats, where
+   * the server sometimes sends only a part of the user's
+   * information. Basic info like name and profile photo
+   * are always available, but other fields may be omitted
+   * despite being available.
+   *
+   * For a rough list of fields that may be missing, see the
+   * [official docs](https://core.telegram.org/constructor/user).
+   *
+   * This currently only ever happens for non-bot users, so if you are building
+   * a normal bot, you can safely ignore this field.
+   *
+   * To fetch the "complete" user information, use one of these methods:
+   *  - {@link TelegramClient.getUsers}
+   *  - {@link TelegramClient.getChat}
+   *  - {@link TelegramClient.getFullChat}.
+   *
+   * Learn more: [Incomplete peers](https://mtcute.dev/guide/topics/peers.html#incomplete-peers)
+   */
+  get isMin() {
+    return this.raw.min;
+  }
+  /** Whether this user is you yourself */
+  get isSelf() {
+    return this.raw.self;
+  }
+  /** Whether this user is in your contacts */
+  get isContact() {
+    return this.raw.contact;
+  }
+  /** Whether you both have each other's contact */
+  get isMutualContact() {
+    return this.raw.mutualContact;
+  }
+  /** Whether this user is in yout "close friends" list */
+  get isCloseFriend() {
+    return this.raw.closeFriend;
+  }
+  /** Whether this user is deleted */
+  get isDeleted() {
+    return this.raw.deleted;
+  }
+  /** Whether this user is a bot */
+  get isBot() {
+    return this.raw.bot;
+  }
+  /**
+   * Whether this user is a bot that can be connected to a
+   * Telegram Business account to receive its messages
+   */
+  get isBusinessBot() {
+    return this.raw.botBusiness;
+  }
+  /** Whether this user is a bot that has access to all messages */
+  get isBotWithHistory() {
+    return this.raw.botChatHistory;
+  }
+  /** Whether this user is a bot that can't be added to chats */
+  get isBotWithoutChats() {
+    return this.raw.botNochats;
+  }
+  /** Whether this bot offers an attachment menu web app */
+  get isBotWithAttachmentMenu() {
+    return this.raw.botAttachMenu;
+  }
+  /** Whether this bot offers an attachment menu web app, and we have it enabled */
+  get isBotAttachmentMenuEnabled() {
+    return this.raw.attachMenuEnabled;
+  }
+  /** Whether this bot can request geolocation when used in inline mode */
+  get isBotWithInlineGeo() {
+    return this.raw.botInlineGeo;
+  }
+  /** Whether this bot can be edited by the current user */
+  get isBotEditable() {
+    return this.raw.botCanEdit;
+  }
+  /** Whether this user has been verified by Telegram */
+  get isVerified() {
+    return this.raw.verified;
+  }
+  /**
+   * Whether this user has been restricted. Bots only.
+   * See {@link restrictionReason} for details
+   */
+  get isRestricted() {
+    return this.raw.restricted;
+  }
+  /**
+   * Reason why this bot was restricted
+   */
+  get restrictionReason() {
+    return this.raw.restrictionReason ?? [];
+  }
+  /** Whether this user has been flagged for scam */
+  get isScam() {
+    return this.raw.scam;
+  }
+  /** Whether this user has been flagged for impersonation */
+  get isFake() {
+    return this.raw.fake;
+  }
+  /** Whether this user is part of the Telegram support team */
+  get isSupport() {
+    return this.raw.support;
+  }
+  /** Whether this user has Premium subscription */
+  get isPremium() {
+    return this.raw.premium;
+  }
+  /** Whether Premium is required to contact this user */
+  get isPremiumRequired() {
+    return this.raw.contactRequirePremium;
+  }
+  /** Number of bot's active users, if available */
+  get botActiveUsers() {
+    return this.raw.botActiveUsers ?? null;
+  }
+  /** Whether this bot has a main app */
+  get hasMainApp() {
+    return this.raw.botHasMainApp;
+  }
+  /** User's or bot's first name */
+  get firstName() {
+    return this.raw.firstName ?? "Deleted Account";
+  }
+  /** User's or bot's last name */
+  get lastName() {
+    return this.raw.lastName ?? null;
+  }
+  static parseStatus(status, bot = false) {
+    let ret;
+    let date;
+    let byMe = false;
+    const us = status;
+    if (bot) {
+      ret = "bot";
+    } else if (!us) {
+      ret = "long_time_ago";
+    } else {
+      switch (us._) {
+        case "userStatusOnline":
+          ret = "online";
+          date = new Date(us.expires * 1e3);
+          break;
+        case "userStatusOffline":
+          ret = "offline";
+          date = new Date(us.wasOnline * 1e3);
+          break;
+        case "userStatusRecently":
+          ret = "recently";
+          byMe = us.byMe;
+          break;
+        case "userStatusLastWeek":
+          ret = "within_week";
+          byMe = us.byMe;
+          break;
+        case "userStatusLastMonth":
+          ret = "within_month";
+          byMe = us.byMe;
+          break;
+        default:
+          ret = "long_time_ago";
+          break;
+      }
+    }
+    return {
+      status: ret,
+      lastOnline: ret === "offline" ? date : null,
+      nextOffline: ret === "online" ? date : null,
+      byMe
+    };
+  }
+  get _parsedStatus() {
+    return User.parseStatus(this.raw.status, this.raw.bot);
+  }
+  /** User's Last Seen & Online status */
+  get status() {
+    return this._parsedStatus.status;
+  }
+  /**
+   * Whether user's online status is hidden because
+   * we have hidden our own online status from them,
+   * and we don't have Premium subscription.
+   */
+  get statusHiddenByMe() {
+    return this._parsedStatus.byMe;
+  }
+  /**
+   * Last time this user was seen online.
+   * Only available if {@link status} is `offline`
+   */
+  get lastOnline() {
+    return this._parsedStatus.lastOnline;
+  }
+  /**
+   * Time when this user will automatically go offline.
+   * Only available if {@link status} is `online`
+   */
+  get nextOffline() {
+    return this._parsedStatus.nextOffline;
+  }
+  /** User's or bot's username */
+  get username() {
+    return this.raw.username ?? this.raw.usernames?.[0]?.username ?? null;
+  }
+  /** User's or bot's usernames (including collectibles) */
+  get usernames() {
+    if (this.raw.username) {
+      return [{ _: "username", username: this.raw.username, active: true }];
+    }
+    if (!this.raw.usernames?.length) {
+      return null;
+    }
+    return this.raw.usernames;
+  }
+  /**
+   * IETF language tag of the user's language
+   *
+   * Only available in some contexts
+   */
+  get language() {
+    return this.raw.langCode ?? null;
+  }
+  /**
+   * User's or bot's assigned DC (data center).
+   * Available only in case the user has set a public profile photo.
+   *
+   * **Note**: this information is approximate; it is based on where
+   * Telegram stores a user profile pictures and does not by any means tell
+   * you the user location (i.e. a user might travel far away, but will still connect
+   * to its assigned DC).
+   * More info at [Pyrogram FAQ](https://docs.pyrogram.org/faq#what-are-the-ip-addresses-of-telegram-data-centers).
+   */
+  get dcId() {
+    return this.raw.photo?.dcId ?? null;
+  }
+  /** User's phone number */
+  get phoneNumber() {
+    return this.raw.phone ?? null;
+  }
+  /**
+   * Get this user's input peer for advanced use-cases.
+   *
+   * > **Note**: for {@link min} users, this method will return
+   * > `mtcute.dummyInputPeerMinUser`, which is actually not a valid input peer.
+   * > These are used to indicate that the user is incomplete, and a message
+   * > reference is needed to resolve the peer.
+   * >
+   * > Such objects are handled by {@link TelegramClient.resolvePeer} method,
+   * > so prefer using it whenever you need an input peer.
+   */
+  get inputPeer() {
+    if (this.raw.min) {
+      return {
+        _: "mtcute.dummyInputPeerMinUser",
+        userId: this.raw.id
+      };
+    }
+    if (!this.raw.accessHash) {
+      throw new MtArgumentError("user's access hash is not available!");
+    }
+    return {
+      _: "inputPeerUser",
+      userId: this.raw.id,
+      accessHash: this.raw.accessHash
+    };
+  }
+  /**
+   * User's or bot's current profile photo, if any.
+   * Suitable for downloads only
+   */
+  get photo() {
+    if (this.raw.photo?._ !== "userProfilePhoto") return null;
+    return new ChatPhoto$2(this.inputPeer, this.raw.photo);
+  }
+  /**
+   * The list of reasons why this bot might be unavailable to some users.
+   * This field is available only in case *isRestricted* is `true`
+   */
+  get restrictions() {
+    return this.raw.restrictionReason ?? null;
+  }
+  /**
+   * User's display name.
+   *
+   * First name and last name if available,
+   * only first name otherwise.
+   */
+  get displayName() {
+    if (!this.firstName) return "Deleted Account";
+    if (this.lastName) return `${this.firstName} ${this.lastName}`;
+    return this.firstName;
+  }
+  /**
+   * User's emoji status, if any.
+   */
+  get emojiStatus() {
+    if (!this.raw.emojiStatus || this.raw.emojiStatus._ === "emojiStatusEmpty") return null;
+    return new EmojiStatus$1(this.raw.emojiStatus);
+  }
+  /** Whether you have hidden (arhived) this user's stories */
+  get storiesHidden() {
+    return this.raw.storiesHidden;
+  }
+  get storiesUnavailable() {
+    return this.raw.storiesUnavailable;
+  }
+  /**
+   * Maximum ID of stories this user has (or 0 if none)
+   */
+  get storiesMaxId() {
+    return this.raw.storiesMaxId ?? 0;
+  }
+  /**
+   * Color that should be used when rendering replies to
+   * their messages and web previews sent by them,
+   * as well as to render the chat title
+   */
+  get color() {
+    return new ChatColors$1(this.raw.id, this.raw.color);
+  }
+  /**
+   * Color that should be used when rendering the header of
+   * the user's profile
+   *
+   * If `null`, a generic header should be used instead
+   */
+  get profileColors() {
+    return this.raw.profileColor ? new ChatColors$1(this.raw.id, this.raw.profileColor) : null;
+  }
+  /**
+   * Create a mention for the user.
+   *
+   * When available and `text` is omitted, this method will return `@username`.
+   * Otherwise, text mention is created.
+   *
+   * Use `null` as `text` (first parameter) to force create a text
+   * mention with display name, even if there is a username.
+   *
+   * > **Note**: This method doesn't format anything on its own.
+   * > Instead, it returns a {@link MessageEntity} that can later
+   * > be used with `html` or `md` template tags
+   *
+   * @param text  Text of the mention.
+   * @example
+   * ```typescript
+   * msg.replyText(html`Hello, ${msg.sender.mention()`)
+   * ```
+   */
+  mention(text) {
+    if (text === void 0 && this.username) {
+      return `@${this.username}`;
+    }
+    if (!text) text = this.displayName;
+    return new MessageEntity$2(
+      {
+        _: "messageEntityMentionName",
+        offset: 0,
+        length: text.length,
+        userId: this.raw.id
+      },
+      text
+    );
+  }
+  /**
+   * Create a permanent mention for this user.
+   *
+   * Permanent* means that this mention will also
+   * contain user's access hash, so even if the user
+   * changes their username or the client forgets
+   * about that user, it can still be mentioned.
+   *
+   * Telegram might change access hash in some cases,
+   * so it may not exactly be *permanent*. The only way
+   * to actually make it permanent is to send it as a message
+   * somewhere and load it from there if needed.
+   *
+   * Note that some users (particularly, users with hidden forwards)
+   * may not be mentioned like this outside the chats you have in common.
+   *
+   * This method is only needed when the result will be
+   * stored somewhere outside current mtcute instance (e.g. saved for later use),
+   * otherwise {@link mention} will be enough.
+   *
+   * > **Note**: This method doesn't format anything on its own.
+   * > Instead, it returns a {@link MessageEntity} that can later
+   * > be used with `html` or `md` template tags
+   *
+   * > **Note**: the resulting text can only be used by clients
+   * > that support mtcute notation of permanent
+   * > mention links (`tg://user?id=123&hash=abc`).
+   * >
+   * > Also note that these permanent mentions are only
+   * > valid for current account, since peer access hashes are
+   * > account-specific and can't be used on another account.
+   * >
+   * > Also note that for some users such mentions might not work at all
+   * > due to privacy settings.
+   *
+   * @param text  Mention text
+   */
+  permanentMention(text) {
+    if (!this.raw.accessHash) {
+      throw new MtArgumentError("User's access hash is not available!");
+    }
+    if (!text) text = this.displayName;
+    return new MessageEntity$2(
+      {
+        _: "messageEntityTextUrl",
+        offset: 0,
+        length: text.length,
+        url: `tg://user?id=${this.id}&hash=${this.raw.accessHash.toString(16)}`
+      },
+      text
+    );
+  }
+}
+const User$1 = /* @__PURE__ */ memoizeGetters(User, [
+  "_parsedStatus",
+  "usernames",
+  "inputPeer",
+  "photo",
+  "emojiStatus",
+  "color",
+  "profileColors"
+]);
+const User$2 = /* @__PURE__ */ makeInspectable(User$1, void 0, ["_parsedStatus"]);
+export {
+  User$2 as User
+};

package/highlevel/types/premium/boost-slot.cjs

@@ -0,0 +1,62 @@
+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 typeAssertions = require("../../../utils/type-assertions.cjs");
+const inspectable = require("../../utils/inspectable.cjs");
+const memoize = require("../../utils/memoize.cjs");
+const chat = require("../peers/chat.cjs");
+class BoostSlot {
+  constructor(raw, _peers) {
+    this.raw = raw;
+    this._peers = _peers;
+  }
+  /** ID of this slot */
+  get id() {
+    return this.raw.slot;
+  }
+  /**
+   * Whether this slot is occupied
+   */
+  get occupied() {
+    return this.raw.peer !== void 0;
+  }
+  /**
+   * Channel that is occupying this slot, if any
+   */
+  get chat() {
+    if (!this.raw.peer) return null;
+    typeAssertions.assertTypeIs("BoostSlot.chat", this.raw.peer, "peerChannel");
+    return new chat.Chat(this._peers.chat(this.raw.peer.channelId));
+  }
+  /**
+   * Date when we started boosting this channel
+   *
+   * If this slot is not occupied, will be `0`
+   */
+  get date() {
+    return new Date(this.raw.date * 1e3);
+  }
+  /**
+   * Date when this boost will automatically expire.
+   */
+  get expireDate() {
+    return new Date(this.raw.expires * 1e3);
+  }
+  /**
+   * If this slot is occupied, returns the date when
+   * we can reassing this slot to another channel.
+   *
+   * If `null`, we can reassign it immediately.
+   */
+  get cooldownUntil() {
+    if (!this.raw.cooldownUntilDate) return null;
+    return new Date(this.raw.cooldownUntilDate * 1e3);
+  }
+}
+const BoostSlot$1 = /* @__PURE__ */ memoize.memoizeGetters(BoostSlot, ["chat"]);
+const BoostSlot$2 = /* @__PURE__ */ inspectable.makeInspectable(BoostSlot$1);
+exports.BoostSlot = BoostSlot$2;

package/highlevel/types/premium/boost-slot.js

@@ -0,0 +1,57 @@
+import { assertTypeIs } from "../../../utils/type-assertions.js";
+import { makeInspectable } from "../../utils/inspectable.js";
+import { memoizeGetters } from "../../utils/memoize.js";
+import { Chat as Chat$2 } from "../peers/chat.js";
+class BoostSlot {
+  constructor(raw, _peers) {
+    this.raw = raw;
+    this._peers = _peers;
+  }
+  /** ID of this slot */
+  get id() {
+    return this.raw.slot;
+  }
+  /**
+   * Whether this slot is occupied
+   */
+  get occupied() {
+    return this.raw.peer !== void 0;
+  }
+  /**
+   * Channel that is occupying this slot, if any
+   */
+  get chat() {
+    if (!this.raw.peer) return null;
+    assertTypeIs("BoostSlot.chat", this.raw.peer, "peerChannel");
+    return new Chat$2(this._peers.chat(this.raw.peer.channelId));
+  }
+  /**
+   * Date when we started boosting this channel
+   *
+   * If this slot is not occupied, will be `0`
+   */
+  get date() {
+    return new Date(this.raw.date * 1e3);
+  }
+  /**
+   * Date when this boost will automatically expire.
+   */
+  get expireDate() {
+    return new Date(this.raw.expires * 1e3);
+  }
+  /**
+   * If this slot is occupied, returns the date when
+   * we can reassing this slot to another channel.
+   *
+   * If `null`, we can reassign it immediately.
+   */
+  get cooldownUntil() {
+    if (!this.raw.cooldownUntilDate) return null;
+    return new Date(this.raw.cooldownUntilDate * 1e3);
+  }
+}
+const BoostSlot$1 = /* @__PURE__ */ memoizeGetters(BoostSlot, ["chat"]);
+const BoostSlot$2 = /* @__PURE__ */ makeInspectable(BoostSlot$1);
+export {
+  BoostSlot$2 as BoostSlot
+};

package/highlevel/types/premium/boost-stats.cjs

@@ -0,0 +1,89 @@
+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 BoostStats {
+  constructor(raw) {
+    this.raw = raw;
+  }
+  /** Whether this channel is being boosted by the current user */
+  get isBoosting() {
+    return this.raw.myBoost;
+  }
+  /**
+   * Current level of boosts in this channel.
+   *
+   * Currently this maps 1-to-1 to the number of stories
+   * the channel can post daily
+   */
+  get level() {
+    return this.raw.level;
+  }
+  /** Whether this channel is already at the maximum level */
+  get isMaxLevel() {
+    return this.raw.nextLevelBoosts === void 0;
+  }
+  /**
+   * The number of boosts acquired from created Telegram Premium
+   * gift codes and giveaways, only available to channel admins
+   */
+  get gifts() {
+    return this.raw.giftBoosts ?? 0;
+  }
+  /**
+   * Number of boosts that were needed for the current level
+   */
+  get currentLevelBoosts() {
+    return this.raw.currentLevelBoosts;
+  }
+  /** Total number of boosts this channel has */
+  get currentBoosts() {
+    return this.raw.boosts;
+  }
+  /**
+   * Number of boosts the channel must have to reach the next level
+   *
+   * `null` if the channel is already at the maximum level
+   */
+  get nextLevelBoosts() {
+    return this.raw.nextLevelBoosts ?? null;
+  }
+  /**
+   * Number of boosts the channel needs in addition to the current value
+   * to reach the next level
+   */
+  get remainingBoosts() {
+    if (!this.raw.nextLevelBoosts) return 0;
+    return this.raw.nextLevelBoosts - this.raw.boosts;
+  }
+  /** If available, total number of subscribers this channel has */
+  get totalSubscribers() {
+    return this.raw.premiumAudience?.total ?? null;
+  }
+  /** If available, total number of Premium subscribers this channel has */
+  get totalPremiumSubscribers() {
+    return this.raw.premiumAudience?.part ?? null;
+  }
+  /** If available, percentage of this channel's subscribers that are Premium */
+  get premiumSubscribersPercentage() {
+    if (!this.raw.premiumAudience) return null;
+    return this.raw.premiumAudience.part / this.raw.premiumAudience.total * 100;
+  }
+  /** URL that would bring up the boost interface */
+  get url() {
+    return this.raw.boostUrl;
+  }
+  /**
+   * If {@link isBoosting}, IDs of the boost slots that are
+   * currently occupied by this channel
+   */
+  get boostSlots() {
+    return this.raw.myBoostSlots ?? [];
+  }
+}
+const BoostStats$1 = /* @__PURE__ */ inspectable.makeInspectable(BoostStats);
+exports.BoostStats = BoostStats$1;