@mtcute/core 0.17.1 → 0.18.0

package/highlevel/methods/files/normalize-input-media.cjs

@@ -0,0 +1,366 @@
+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 fileId = require("@mtcute/file-id");
+const tl = require("@mtcute/tl");
+const Long = require("long");
+const typeAssertions = require("../../../utils/type-assertions.cjs");
+const uploadedFile = require("../../types/files/uploaded-file.cjs");
+const entities = require("../../types/misc/entities.cjs");
+const convertFileId = require("../../utils/convert-file-id.cjs");
+const miscUtils = require("../../utils/misc-utils.cjs");
+const voiceUtils = require("../../utils/voice-utils.cjs");
+const normalizeText = require("../misc/normalize-text.cjs");
+const resolvePeer = require("../users/resolve-peer.cjs");
+const normalizeInputFile = require("./normalize-input-file.cjs");
+const uploadFile = require("./upload-file.cjs");
+async function _normalizeInputMedia(client, media, params = {}, uploadMedia = false) {
+  if (tl.tl.isAnyInputMedia(media)) {
+    switch (media._) {
+      case "inputMediaStory":
+        return {
+          ...media,
+          peer: await resolvePeer.resolvePeer(client, media.peer)
+        };
+    }
+    return media;
+  }
+  if (media.type === "venue") {
+    return {
+      _: "inputMediaVenue",
+      geoPoint: {
+        _: "inputGeoPoint",
+        lat: media.latitude,
+        long: media.longitude
+      },
+      title: media.title,
+      address: media.address,
+      provider: media.source?.provider ?? "",
+      venueId: media.source?.id ?? "",
+      venueType: media.source?.type ?? ""
+    };
+  }
+  if (media.type === "geo") {
+    return {
+      _: "inputMediaGeoPoint",
+      geoPoint: {
+        _: "inputGeoPoint",
+        lat: media.latitude,
+        long: media.longitude
+      }
+    };
+  }
+  if (media.type === "geo_live") {
+    return {
+      _: "inputMediaGeoLive",
+      geoPoint: {
+        _: "inputGeoPoint",
+        lat: media.latitude,
+        long: media.longitude
+      },
+      stopped: media.stopped,
+      heading: media.heading,
+      period: media.period,
+      proximityNotificationRadius: media.proximityNotificationRadius
+    };
+  }
+  if (media.type === "dice") {
+    return {
+      _: "inputMediaDice",
+      emoticon: media.emoji
+    };
+  }
+  if (media.type === "contact") {
+    return {
+      _: "inputMediaContact",
+      phoneNumber: media.phone,
+      firstName: media.firstName,
+      lastName: media.lastName ?? "",
+      vcard: media.vcard ?? ""
+    };
+  }
+  if (media.type === "game") {
+    return {
+      _: "inputMediaGame",
+      id: typeof media.game === "string" ? {
+        _: "inputGameShortName",
+        botId: { _: "inputUserSelf" },
+        shortName: media.game
+      } : media.game
+    };
+  }
+  if (media.type === "invoice") {
+    return {
+      _: "inputMediaInvoice",
+      title: media.title,
+      description: media.description,
+      photo: typeof media.photo === "string" ? {
+        _: "inputWebDocument",
+        url: media.photo,
+        mimeType: "image/jpeg",
+        size: 0,
+        attributes: []
+      } : media.photo,
+      invoice: media.invoice,
+      payload: media.payload,
+      provider: media.token,
+      providerData: {
+        _: "dataJSON",
+        data: JSON.stringify(media.providerData)
+      },
+      startParam: media.startParam,
+      extendedMedia: media.extendedMedia ? await _normalizeInputMedia(client, media.extendedMedia, params) : void 0
+    };
+  }
+  if (media.type === "poll" || media.type === "quiz") {
+    const answers = media.answers.map((ans, idx) => {
+      if (typeof ans === "object" && tl.tl.isAnyPollAnswer(ans)) return ans;
+      return {
+        _: "pollAnswer",
+        text: entities.inputTextToTl(ans),
+        // emulate the behaviour of most implementations
+        option: new Uint8Array([48 + idx])
+      };
+    });
+    let correct;
+    let solution;
+    let solutionEntities;
+    if (media.type === "quiz") {
+      let input2 = media.correct;
+      if (!Array.isArray(input2)) input2 = [input2];
+      correct = input2.map((it) => {
+        if (typeof it === "number") {
+          return answers[it].option;
+        }
+        return it;
+      });
+      if (media.solution) {
+        [solution, solutionEntities] = await normalizeText._normalizeInputText(client, media.solution);
+      }
+    }
+    return {
+      _: "inputMediaPoll",
+      poll: {
+        _: "poll",
+        closed: media.closed,
+        id: Long.ZERO,
+        publicVoters: media.public,
+        multipleChoice: media.multiple,
+        quiz: media.type === "quiz",
+        question: entities.inputTextToTl(media.question),
+        answers,
+        closePeriod: media.closePeriod,
+        closeDate: miscUtils.normalizeDate(media.closeDate)
+      },
+      correctAnswers: correct,
+      solution,
+      solutionEntities
+    };
+  }
+  if (media.type === "story") {
+    return {
+      _: "inputMediaStory",
+      peer: await resolvePeer.resolvePeer(client, media.peer),
+      id: media.id
+    };
+  }
+  if (media.type === "webpage") {
+    return {
+      _: "inputMediaWebPage",
+      forceLargeMedia: media.size === "large",
+      forceSmallMedia: media.size === "small",
+      optional: !media.required,
+      url: media.url
+    };
+  }
+  if (media.type === "paid") {
+    let medias;
+    if (Array.isArray(media.media)) {
+      medias = await Promise.all(media.media.map((m) => _normalizeInputMedia(client, m, params)));
+    } else {
+      medias = [await _normalizeInputMedia(client, media.media, params)];
+    }
+    return {
+      _: "inputMediaPaidMedia",
+      starsAmount: Long.isLong(media.starsAmount) ? media.starsAmount : Long.fromNumber(media.starsAmount),
+      extendedMedia: medias,
+      payload: media.payload
+    };
+  }
+  let inputFile;
+  let thumb;
+  let mime = "application/octet-stream";
+  const upload = async (file) => {
+    let sendMime;
+    if (media.type === "sticker") {
+      sendMime = media.isAnimated ? "application/x-tgsticker" : "image/webp";
+    } else {
+      sendMime = media.fileMime;
+    }
+    const uploaded = await uploadFile.uploadFile(client, {
+      file,
+      progressCallback: params.progressCallback,
+      fileName: media.fileName,
+      fileMime: sendMime,
+      fileSize: media.fileSize,
+      requireFileSize: media.type === "photo",
+      requireExtension: media.type === "photo"
+    });
+    inputFile = uploaded.inputFile;
+    mime = uploaded.mime;
+  };
+  const uploadPeer = params.uploadPeer ?? { _: "inputPeerSelf" };
+  const uploadMediaIfNeeded = async (inputMedia, photo) => {
+    if (!uploadMedia) return inputMedia;
+    const res = await client.call({
+      _: "messages.uploadMedia",
+      peer: uploadPeer,
+      media: inputMedia,
+      businessConnectionId: params.businessConnectionId
+    });
+    if (photo) {
+      typeAssertions.assertTypeIs("normalizeInputMedia (@ messages.uploadMedia)", res, "messageMediaPhoto");
+      typeAssertions.assertTypeIs("normalizeInputMedia (@ messages.uploadMedia)", res.photo, "photo");
+      return {
+        _: "inputMediaPhoto",
+        id: {
+          _: "inputPhoto",
+          id: res.photo.id,
+          accessHash: res.photo.accessHash,
+          fileReference: res.photo.fileReference
+        },
+        ttlSeconds: media.ttlSeconds,
+        spoiler: media.type === "video" && media.spoiler
+      };
+    }
+    typeAssertions.assertTypeIs("normalizeInputMedia (@ messages.uploadMedia)", res, "messageMediaDocument");
+    typeAssertions.assertTypeIs("normalizeInputMedia (@ messages.uploadMedia)", res.document, "document");
+    return {
+      _: "inputMediaDocument",
+      id: {
+        _: "inputDocument",
+        id: res.document.id,
+        accessHash: res.document.accessHash,
+        fileReference: res.document.fileReference
+      },
+      ttlSeconds: media.ttlSeconds,
+      spoiler: media.type === "video" && media.spoiler
+    };
+  };
+  const input = media.file;
+  if (fileId.tdFileId.isFileIdLike(input)) {
+    if (typeof input === "string" && input.match(/^https?:\/\//)) {
+      return uploadMediaIfNeeded(
+        {
+          _: media.type === "photo" ? "inputMediaPhotoExternal" : "inputMediaDocumentExternal",
+          url: input
+        },
+        media.type === "photo"
+      );
+    } else if (typeof input === "string" && input.match(/^file:/)) {
+      await upload(input.substring(5));
+    } else {
+      const parsed = typeof input === "string" ? fileId.parseFileId(input) : input;
+      if (parsed.location._ === "photo") {
+        return {
+          _: "inputMediaPhoto",
+          id: convertFileId.fileIdToInputPhoto(parsed)
+        };
+      } else if (parsed.location._ === "web") {
+        return uploadMediaIfNeeded(
+          {
+            _: parsed.type === fileId.tdFileId.FileType.Photo ? "inputMediaPhotoExternal" : "inputMediaDocumentExternal",
+            url: parsed.location.url
+          },
+          parsed.type === fileId.tdFileId.FileType.Photo
+        );
+      }
+      return {
+        _: "inputMediaDocument",
+        id: convertFileId.fileIdToInputDocument(parsed)
+      };
+    }
+  } else if (typeof input === "object" && tl.tl.isAnyInputMedia(input)) {
+    return input;
+  } else if (uploadedFile.isUploadedFile(input)) {
+    inputFile = input.inputFile;
+    mime = input.mime;
+  } else if (typeof input === "object" && tl.tl.isAnyInputFile(input)) {
+    inputFile = input;
+  } else {
+    await upload(input);
+  }
+  if (!inputFile) throw new Error("should not happen");
+  if (media.type === "photo") {
+    return uploadMediaIfNeeded(
+      {
+        _: "inputMediaUploadedPhoto",
+        file: inputFile,
+        ttlSeconds: media.ttlSeconds,
+        spoiler: media.spoiler
+      },
+      true
+    );
+  }
+  if ("thumb" in media && media.thumb) {
+    thumb = await normalizeInputFile._normalizeInputFile(client, media.thumb, {});
+  }
+  const attributes = [];
+  if (media.type !== "voice") {
+    attributes.push({
+      _: "documentAttributeFilename",
+      fileName: media.fileName || (inputFile._ === "inputFileStoryDocument" ? "story" : inputFile.name)
+    });
+  }
+  if (media.type === "video") {
+    attributes.push({
+      _: "documentAttributeVideo",
+      duration: media.duration || 0,
+      w: media.width || 0,
+      h: media.height || 0,
+      supportsStreaming: media.supportsStreaming,
+      roundMessage: media.isRound
+    });
+    if (media.isAnimated) {
+      attributes.push({ _: "documentAttributeAnimated" });
+    }
+  }
+  if (media.type === "audio" || media.type === "voice") {
+    attributes.push({
+      _: "documentAttributeAudio",
+      voice: media.type === "voice",
+      duration: media.duration || 0,
+      title: media.type === "audio" ? media.title : void 0,
+      performer: media.type === "audio" ? media.performer : void 0,
+      waveform: media.type === "voice" && media.waveform ? voiceUtils.encodeWaveform(media.waveform) : void 0
+    });
+  }
+  if (media.type === "sticker") {
+    attributes.push({
+      _: "documentAttributeSticker",
+      stickerset: {
+        _: "inputStickerSetEmpty"
+      },
+      alt: media.alt ?? ""
+    });
+  }
+  return uploadMediaIfNeeded(
+    {
+      _: "inputMediaUploadedDocument",
+      nosoundVideo: media.type === "video" && media.isAnimated,
+      forceFile: media.type === "document",
+      file: inputFile,
+      thumb,
+      mimeType: mime,
+      attributes,
+      ttlSeconds: media.ttlSeconds,
+      spoiler: media.type === "video" && media.spoiler
+    },
+    false
+  );
+}
+exports._normalizeInputMedia = _normalizeInputMedia;

package/highlevel/methods/files/normalize-input-media.d.cts

@@ -0,0 +1,12 @@
+import { ITelegramClient } from '../../client.types.js';
+import { InputMediaLike } from '../../types/media/input-media/types.js';
+import { tl } from '@mtcute/tl';
+/**
+ * Normalize an {@link InputMediaLike} to `InputMedia`,
+ * uploading the file if needed.
+ */
+export declare function _normalizeInputMedia(client: ITelegramClient, media: InputMediaLike, params?: {
+    progressCallback?: (uploaded: number, total: number) => void;
+    uploadPeer?: tl.TypeInputPeer;
+    businessConnectionId?: string;
+}, uploadMedia?: boolean): Promise<tl.TypeInputMedia>;

package/highlevel/methods/files/normalize-input-media.d.ts

@@ -1,6 +1,6 @@
-import { tl } from '@mtcute/tl';
 import { ITelegramClient } from '../../client.types.js';
 import { InputMediaLike } from '../../types/media/input-media/types.js';
+import { tl } from '@mtcute/tl';
 /**
  * Normalize an {@link InputMediaLike} to `InputMedia`,
  * uploading the file if needed.