@mtcute/core 0.17.1 → 0.18.0

package/highlevel/types/media/photo.cjs

@@ -0,0 +1,164 @@
+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 memoize = require("../../utils/memoize.cjs");
+const thumbnail = require("./thumbnail.cjs");
+const inspectable = require("../../utils/inspectable.cjs");
+const fileLocation = require("../files/file-location.cjs");
+class Photo extends fileLocation.FileLocation {
+  constructor(raw, media) {
+    const location = {
+      _: "inputPhotoFileLocation",
+      id: raw.id,
+      fileReference: raw.fileReference,
+      accessHash: raw.accessHash,
+      thumbSize: ""
+    };
+    let size;
+    let width;
+    let height;
+    let bestSize;
+    const progressive = raw.sizes.find((it) => it._ === "photoSizeProgressive");
+    if (progressive) {
+      location.thumbSize = progressive.type;
+      size = Math.max(...progressive.sizes);
+      width = progressive.w;
+      height = progressive.h;
+      bestSize = progressive;
+    } else {
+      let max = null;
+      for (const sz of raw.sizes) {
+        if (sz._ === "photoSize" && (!max || sz.size > max.size)) {
+          max = sz;
+        }
+      }
+      if (max) {
+        location.thumbSize = max.type;
+        size = max.size;
+        width = max.w;
+        height = max.h;
+        bestSize = max;
+      } else {
+        throw new errors.MtArgumentError("Photo does not have any sizes");
+      }
+    }
+    super(location, size, raw.dcId);
+    this.raw = raw;
+    this.media = media;
+    this._bestSize = bestSize;
+    this.width = width;
+    this.height = height;
+    this.type = "photo";
+  }
+  type = "photo";
+  /** Biggest available photo width */
+  width;
+  /** Biggest available photo height */
+  height;
+  _bestSize;
+  /**
+   * Photo ID
+   */
+  get id() {
+    return this.raw.id;
+  }
+  /** Date this photo was sent */
+  get date() {
+    return new Date(this.raw.date * 1e3);
+  }
+  /**
+   * Whether this photo is an animated profile picture
+   */
+  get isAnimatedAvatar() {
+    return Boolean(this.raw.videoSizes?.some((s) => s._ === "videoSize" && s.type === "u"));
+  }
+  /**
+   * Whether this photo is an animated profile picture, built from an emoji/sticker markup
+   */
+  get isMarkupAvatar() {
+    return Boolean(
+      this.raw.videoSizes?.some((s) => s._ === "videoSizeEmojiMarkup" || s._ === "videoSizeStickerMarkup")
+    );
+  }
+  /** Whether this photo is hidden with a spoiler */
+  get hasSpoiler() {
+    return this.media?.spoiler ?? false;
+  }
+  /** For self-destructing photos, TTL in seconds */
+  get ttlSeconds() {
+    return this.media?.ttlSeconds ?? null;
+  }
+  /**
+   * Available thumbnails.
+   *
+   * **Note**: This list will also contain the largest thumbnail that is
+   * represented by the current object.
+   */
+  get thumbnails() {
+    const res = this.raw.sizes.map((sz) => new thumbnail.Thumbnail(this.raw, sz));
+    this.raw.videoSizes?.forEach((sz) => res.push(new thumbnail.Thumbnail(this.raw, sz)));
+    return res;
+  }
+  /**
+   * Get a photo thumbnail by its type.
+   *
+   * Thumbnail types are described in the
+   * [Telegram docs](https://core.telegram.org/api/files#image-thumbnail-types),
+   * and are also available as static members of {@link Thumbnail} for convenience.
+   *
+   * @param type  Thumbnail type
+   */
+  getThumbnail(type) {
+    return this.thumbnails.find((it) => it.type === type) ?? null;
+  }
+  /**
+   * Get TDLib and Bot API compatible File ID
+   * representing this photo's best thumbnail.
+   */
+  get fileId() {
+    if (!this._bestSize) {
+      throw new errors.MtArgumentError("Cannot get File ID for this photo");
+    }
+    return this.getThumbnail(this._bestSize.type).fileId;
+  }
+  /**
+   * Get TDLib and Bot API compatible Unique File ID
+   * representing this photo's best thumbnail.
+   */
+  get uniqueFileId() {
+    if (!this._bestSize) {
+      throw new errors.MtArgumentError("Cannot get File ID for this photo");
+    }
+    return this.getThumbnail(this._bestSize.type).uniqueFileId;
+  }
+  /**
+   * Input photo generated from this object.
+   */
+  get inputPhoto() {
+    return {
+      _: "inputPhoto",
+      id: this.raw.id,
+      accessHash: this.raw.accessHash,
+      fileReference: this.raw.fileReference
+    };
+  }
+  /**
+   * Input media generated from this object,
+   * to be used in {@link InputMediaLike} and
+   * {@link TelegramClient.sendMedia}
+   */
+  get inputMedia() {
+    return {
+      _: "inputMediaPhoto",
+      id: this.inputPhoto
+    };
+  }
+}
+const Photo$1 = /* @__PURE__ */ memoize.memoizeGetters(Photo, ["thumbnails", "fileId", "uniqueFileId"]);
+const Photo$2 = /* @__PURE__ */ inspectable.makeInspectable(Photo$1, ["fileSize", "dcId", "width", "height"], ["inputMedia", "inputPhoto"]);
+exports.Photo = Photo$2;

package/highlevel/types/media/photo.d.cts

@@ -0,0 +1,72 @@
+import { tl } from '@mtcute/tl';
+import { FileLocation } from '../files/index.js';
+import { Thumbnail } from './thumbnail.js';
+/**
+ * A photo
+ */
+export declare class Photo extends FileLocation {
+    readonly raw: tl.RawPhoto;
+    readonly media?: tl.RawMessageMediaPhoto | undefined;
+    readonly type: "photo";
+    /** Biggest available photo width */
+    readonly width: number;
+    /** Biggest available photo height */
+    readonly height: number;
+    private _bestSize?;
+    constructor(raw: tl.RawPhoto, media?: tl.RawMessageMediaPhoto | undefined);
+    /**
+     * Photo ID
+     */
+    get id(): tl.Long;
+    /** Date this photo was sent */
+    get date(): Date;
+    /**
+     * Whether this photo is an animated profile picture
+     */
+    get isAnimatedAvatar(): boolean;
+    /**
+     * Whether this photo is an animated profile picture, built from an emoji/sticker markup
+     */
+    get isMarkupAvatar(): boolean;
+    /** Whether this photo is hidden with a spoiler */
+    get hasSpoiler(): boolean;
+    /** For self-destructing photos, TTL in seconds */
+    get ttlSeconds(): number | null;
+    /**
+     * Available thumbnails.
+     *
+     * **Note**: This list will also contain the largest thumbnail that is
+     * represented by the current object.
+     */
+    get thumbnails(): ReadonlyArray<Thumbnail>;
+    /**
+     * Get a photo thumbnail by its type.
+     *
+     * Thumbnail types are described in the
+     * [Telegram docs](https://core.telegram.org/api/files#image-thumbnail-types),
+     * and are also available as static members of {@link Thumbnail} for convenience.
+     *
+     * @param type  Thumbnail type
+     */
+    getThumbnail(type: string): Thumbnail | null;
+    /**
+     * Get TDLib and Bot API compatible File ID
+     * representing this photo's best thumbnail.
+     */
+    get fileId(): string;
+    /**
+     * Get TDLib and Bot API compatible Unique File ID
+     * representing this photo's best thumbnail.
+     */
+    get uniqueFileId(): string;
+    /**
+     * Input photo generated from this object.
+     */
+    get inputPhoto(): tl.TypeInputPhoto;
+    /**
+     * Input media generated from this object,
+     * to be used in {@link InputMediaLike} and
+     * {@link TelegramClient.sendMedia}
+     */
+    get inputMedia(): tl.TypeInputMedia;
+}

package/highlevel/types/media/photo.js

@@ -0,0 +1,159 @@
+import { MtArgumentError } from "../../../types/errors.js";
+import { memoizeGetters } from "../../utils/memoize.js";
+import { Thumbnail as Thumbnail$2 } from "./thumbnail.js";
+import { makeInspectable } from "../../utils/inspectable.js";
+import { FileLocation as FileLocation$1 } from "../files/file-location.js";
+class Photo extends FileLocation$1 {
+  constructor(raw, media) {
+    const location = {
+      _: "inputPhotoFileLocation",
+      id: raw.id,
+      fileReference: raw.fileReference,
+      accessHash: raw.accessHash,
+      thumbSize: ""
+    };
+    let size;
+    let width;
+    let height;
+    let bestSize;
+    const progressive = raw.sizes.find((it) => it._ === "photoSizeProgressive");
+    if (progressive) {
+      location.thumbSize = progressive.type;
+      size = Math.max(...progressive.sizes);
+      width = progressive.w;
+      height = progressive.h;
+      bestSize = progressive;
+    } else {
+      let max = null;
+      for (const sz of raw.sizes) {
+        if (sz._ === "photoSize" && (!max || sz.size > max.size)) {
+          max = sz;
+        }
+      }
+      if (max) {
+        location.thumbSize = max.type;
+        size = max.size;
+        width = max.w;
+        height = max.h;
+        bestSize = max;
+      } else {
+        throw new MtArgumentError("Photo does not have any sizes");
+      }
+    }
+    super(location, size, raw.dcId);
+    this.raw = raw;
+    this.media = media;
+    this._bestSize = bestSize;
+    this.width = width;
+    this.height = height;
+    this.type = "photo";
+  }
+  type = "photo";
+  /** Biggest available photo width */
+  width;
+  /** Biggest available photo height */
+  height;
+  _bestSize;
+  /**
+   * Photo ID
+   */
+  get id() {
+    return this.raw.id;
+  }
+  /** Date this photo was sent */
+  get date() {
+    return new Date(this.raw.date * 1e3);
+  }
+  /**
+   * Whether this photo is an animated profile picture
+   */
+  get isAnimatedAvatar() {
+    return Boolean(this.raw.videoSizes?.some((s) => s._ === "videoSize" && s.type === "u"));
+  }
+  /**
+   * Whether this photo is an animated profile picture, built from an emoji/sticker markup
+   */
+  get isMarkupAvatar() {
+    return Boolean(
+      this.raw.videoSizes?.some((s) => s._ === "videoSizeEmojiMarkup" || s._ === "videoSizeStickerMarkup")
+    );
+  }
+  /** Whether this photo is hidden with a spoiler */
+  get hasSpoiler() {
+    return this.media?.spoiler ?? false;
+  }
+  /** For self-destructing photos, TTL in seconds */
+  get ttlSeconds() {
+    return this.media?.ttlSeconds ?? null;
+  }
+  /**
+   * Available thumbnails.
+   *
+   * **Note**: This list will also contain the largest thumbnail that is
+   * represented by the current object.
+   */
+  get thumbnails() {
+    const res = this.raw.sizes.map((sz) => new Thumbnail$2(this.raw, sz));
+    this.raw.videoSizes?.forEach((sz) => res.push(new Thumbnail$2(this.raw, sz)));
+    return res;
+  }
+  /**
+   * Get a photo thumbnail by its type.
+   *
+   * Thumbnail types are described in the
+   * [Telegram docs](https://core.telegram.org/api/files#image-thumbnail-types),
+   * and are also available as static members of {@link Thumbnail} for convenience.
+   *
+   * @param type  Thumbnail type
+   */
+  getThumbnail(type) {
+    return this.thumbnails.find((it) => it.type === type) ?? null;
+  }
+  /**
+   * Get TDLib and Bot API compatible File ID
+   * representing this photo's best thumbnail.
+   */
+  get fileId() {
+    if (!this._bestSize) {
+      throw new MtArgumentError("Cannot get File ID for this photo");
+    }
+    return this.getThumbnail(this._bestSize.type).fileId;
+  }
+  /**
+   * Get TDLib and Bot API compatible Unique File ID
+   * representing this photo's best thumbnail.
+   */
+  get uniqueFileId() {
+    if (!this._bestSize) {
+      throw new MtArgumentError("Cannot get File ID for this photo");
+    }
+    return this.getThumbnail(this._bestSize.type).uniqueFileId;
+  }
+  /**
+   * Input photo generated from this object.
+   */
+  get inputPhoto() {
+    return {
+      _: "inputPhoto",
+      id: this.raw.id,
+      accessHash: this.raw.accessHash,
+      fileReference: this.raw.fileReference
+    };
+  }
+  /**
+   * Input media generated from this object,
+   * to be used in {@link InputMediaLike} and
+   * {@link TelegramClient.sendMedia}
+   */
+  get inputMedia() {
+    return {
+      _: "inputMediaPhoto",
+      id: this.inputPhoto
+    };
+  }
+}
+const Photo$1 = /* @__PURE__ */ memoizeGetters(Photo, ["thumbnails", "fileId", "uniqueFileId"]);
+const Photo$2 = /* @__PURE__ */ makeInspectable(Photo$1, ["fileSize", "dcId", "width", "height"], ["inputMedia", "inputPhoto"]);
+export {
+  Photo$2 as Photo
+};

package/highlevel/types/media/poll.cjs

@@ -0,0 +1,188 @@
+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 Long = require("long");
+const memoize = require("../../utils/memoize.cjs");
+const messageEntity = require("../messages/message-entity.cjs");
+const inspectable = require("../../utils/inspectable.cjs");
+class PollAnswer {
+  constructor(raw, result) {
+    this.raw = raw;
+    this.result = result;
+  }
+  /**
+   * Answer text
+   */
+  get text() {
+    return this.raw.text.text;
+  }
+  /**
+   * Format entities for {@link text}, currently may only contain custom emojis
+   */
+  get textEntities() {
+    return this.raw.text.entities.map((ent) => new messageEntity.MessageEntity(ent, this.raw.text.text));
+  }
+  /**
+   * Answer data, to be passed to
+   * {@link TelegramClient.sendVote}
+   */
+  get data() {
+    return this.raw.option;
+  }
+  /**
+   * Number of people who has chosen this result.
+   * If not available (i.e. not voted yet)
+   *
+   * @default
+   */
+  get voters() {
+    return this.result?.voters ?? 0;
+  }
+  /**
+   * Whether this answer was chosen by the current user
+   */
+  get chosen() {
+    return Boolean(this.result?.chosen);
+  }
+  /**
+   * Whether this answer is correct (for quizzes).
+   * Not available before choosing an answer
+   *
+   * @default
+   */
+  get correct() {
+    return Boolean(this.result?.correct);
+  }
+}
+const PollAnswer$1 = /* @__PURE__ */ memoize.memoizeGetters(PollAnswer, ["textEntities"]);
+const PollAnswer$2 = /* @__PURE__ */ inspectable.makeInspectable(PollAnswer$1);
+class Poll {
+  constructor(raw, _peers, results) {
+    this.raw = raw;
+    this._peers = _peers;
+    this.results = results;
+  }
+  type = "poll";
+  /**
+   * Unique identifier of the poll
+   */
+  get id() {
+    return this.raw.id;
+  }
+  /**
+   * Poll question
+   */
+  get question() {
+    return this.raw.question.text;
+  }
+  /**
+   * Format entities for {@link question} (currently may only contain custom emojis)
+   */
+  get questionEntities() {
+    return this.raw.question.entities.map((ent) => new messageEntity.MessageEntity(ent, this.raw.question.text));
+  }
+  /**
+   * List of answers in this poll
+   */
+  get answers() {
+    const results = this.results?.results;
+    return this.raw.answers.map((ans, idx) => {
+      if (results) {
+        return new PollAnswer(ans, results[idx]);
+      }
+      return new PollAnswer(ans);
+    });
+  }
+  /**
+   * Total number of voters in this poll, if available
+   */
+  get voters() {
+    return this.results?.totalVoters ?? 0;
+  }
+  /**
+   * Whether this poll is closed, i.e. does not
+   * accept votes anymore
+   */
+  get isClosed() {
+    return this.raw.closed;
+  }
+  /**
+   * Whether this poll is public, i.e. you
+   * list of voters is publicly available
+   */
+  get isPublic() {
+    return this.raw.publicVoters;
+  }
+  /**
+   * Whether this is a quiz
+   */
+  get isQuiz() {
+    return this.raw.quiz;
+  }
+  /**
+   * Whether this poll accepts multiple answers
+   */
+  get isMultiple() {
+    return this.raw.multipleChoice;
+  }
+  /**
+   * Solution for the quiz, only available
+   * in case you have already answered
+   */
+  get solution() {
+    return this.results?.solution ?? null;
+  }
+  /**
+   * Format entities for {@link solution}, only available
+   * in case you have already answered
+   */
+  get solutionEntities() {
+    if (!this.results) return null;
+    const res = [];
+    if (this.results.solutionEntities?.length) {
+      for (const ent of this.results.solutionEntities) {
+        res.push(new messageEntity.MessageEntity(ent, this.results.solution));
+      }
+    }
+    return res;
+  }
+  /**
+   * Input media TL object generated from this object,
+   * to be used inside {@link InputMediaLike} and
+   * {@link TelegramClient.sendMedia}
+   *
+   * A few notes:
+   *  - Using this will result in an
+   *    independent poll, which will not
+   *    be auto-updated with the current.
+   *  - If this is a quiz, a normal poll
+   *    will be returned since the client does not
+   *    know the correct answer.
+   *  - This always returns a non-closed poll,
+   *    even if the current poll was closed
+   */
+  get inputMedia() {
+    return {
+      _: "inputMediaPoll",
+      poll: {
+        _: "poll",
+        closed: false,
+        id: Long.ZERO,
+        publicVoters: this.raw.publicVoters,
+        multipleChoice: this.raw.multipleChoice,
+        question: this.raw.question,
+        answers: this.raw.answers,
+        closePeriod: this.raw.closePeriod,
+        closeDate: this.raw.closeDate
+      }
+    };
+  }
+}
+const Poll$1 = /* @__PURE__ */ memoize.memoizeGetters(Poll, ["answers", "solutionEntities", "questionEntities"]);
+const Poll$2 = /* @__PURE__ */ inspectable.makeInspectable(Poll$1, void 0, ["inputMedia"]);
+exports.Poll = Poll$2;
+exports.PollAnswer = PollAnswer$2;

package/highlevel/types/media/poll.d.cts

@@ -0,0 +1,110 @@
+import { tl } from '@mtcute/tl';
+import { PeersIndex } from '../peers/peers-index.js';
+import { MessageEntity } from '../messages/message-entity.js';
+export declare class PollAnswer {
+    readonly raw: tl.TypePollAnswer;
+    readonly result?: tl.RawPollAnswerVoters | undefined;
+    constructor(raw: tl.TypePollAnswer, result?: tl.RawPollAnswerVoters | undefined);
+    /**
+     * Answer text
+     */
+    get text(): string;
+    /**
+     * Format entities for {@link text}, currently may only contain custom emojis
+     */
+    get textEntities(): ReadonlyArray<MessageEntity>;
+    /**
+     * Answer data, to be passed to
+     * {@link TelegramClient.sendVote}
+     */
+    get data(): Uint8Array;
+    /**
+     * Number of people who has chosen this result.
+     * If not available (i.e. not voted yet)
+     *
+     * @default
+     */
+    get voters(): number;
+    /**
+     * Whether this answer was chosen by the current user
+     */
+    get chosen(): boolean;
+    /**
+     * Whether this answer is correct (for quizzes).
+     * Not available before choosing an answer
+     *
+     * @default
+     */
+    get correct(): boolean;
+}
+export declare class Poll {
+    readonly raw: tl.TypePoll;
+    readonly _peers: PeersIndex;
+    readonly results?: tl.RawPollResults | undefined;
+    readonly type: "poll";
+    constructor(raw: tl.TypePoll, _peers: PeersIndex, results?: tl.RawPollResults | undefined);
+    /**
+     * Unique identifier of the poll
+     */
+    get id(): tl.Long;
+    /**
+     * Poll question
+     */
+    get question(): string;
+    /**
+     * Format entities for {@link question} (currently may only contain custom emojis)
+     */
+    get questionEntities(): ReadonlyArray<MessageEntity>;
+    /**
+     * List of answers in this poll
+     */
+    get answers(): ReadonlyArray<PollAnswer>;
+    /**
+     * Total number of voters in this poll, if available
+     */
+    get voters(): number;
+    /**
+     * Whether this poll is closed, i.e. does not
+     * accept votes anymore
+     */
+    get isClosed(): boolean;
+    /**
+     * Whether this poll is public, i.e. you
+     * list of voters is publicly available
+     */
+    get isPublic(): boolean;
+    /**
+     * Whether this is a quiz
+     */
+    get isQuiz(): boolean;
+    /**
+     * Whether this poll accepts multiple answers
+     */
+    get isMultiple(): boolean;
+    /**
+     * Solution for the quiz, only available
+     * in case you have already answered
+     */
+    get solution(): string | null;
+    /**
+     * Format entities for {@link solution}, only available
+     * in case you have already answered
+     */
+    get solutionEntities(): ReadonlyArray<MessageEntity> | null;
+    /**
+     * Input media TL object generated from this object,
+     * to be used inside {@link InputMediaLike} and
+     * {@link TelegramClient.sendMedia}
+     *
+     * A few notes:
+     *  - Using this will result in an
+     *    independent poll, which will not
+     *    be auto-updated with the current.
+     *  - If this is a quiz, a normal poll
+     *    will be returned since the client does not
+     *    know the correct answer.
+     *  - This always returns a non-closed poll,
+     *    even if the current poll was closed
+     */
+    get inputMedia(): tl.TypeInputMedia;
+}

package/highlevel/types/media/poll.d.ts

@@ -1,6 +1,6 @@
 import { tl } from '@mtcute/tl';
-import { MessageEntity } from '../messages/message-entity.js';
 import { PeersIndex } from '../peers/peers-index.js';
+import { MessageEntity } from '../messages/message-entity.js';
 export declare class PollAnswer {
     readonly raw: tl.TypePollAnswer;
     readonly result?: tl.RawPollAnswerVoters | undefined;