@mtcute/core 0.17.0 → 0.18.0-rc.5

package/highlevel/updates/parsed.cjs

@@ -0,0 +1,48 @@
+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 utils = require("@fuman/utils");
+const parseUpdate = require("../types/updates/parse-update.cjs");
+function makeParsedUpdateHandler(params) {
+  const { messageGroupingInterval, onUpdate } = params;
+  if (!messageGroupingInterval) {
+    return (info) => {
+      const parsed = parseUpdate._parseUpdate(info);
+      if (parsed) onUpdate(parsed);
+    };
+  }
+  const pending = /* @__PURE__ */ new Map();
+  return (info) => {
+    const parsed = parseUpdate._parseUpdate(info);
+    if (parsed) {
+      if (parsed.name === "new_message" || parsed.name === "new_business_message") {
+        const group = parsed.data.groupedIdUnique;
+        if (group) {
+          const isBusiness = parsed.name === "new_business_message";
+          const pendingGroup = pending.get(group);
+          if (pendingGroup) {
+            pendingGroup[0].push(parsed.data);
+          } else {
+            const messages = [parsed.data];
+            const timeout = utils.timers.setTimeout(() => {
+              pending.delete(group);
+              if (isBusiness) {
+                onUpdate({ name: "business_message_group", data: messages });
+              } else {
+                onUpdate({ name: "message_group", data: messages });
+              }
+            }, messageGroupingInterval);
+            pending.set(group, [messages, timeout]);
+          }
+          return;
+        }
+      }
+      onUpdate(parsed);
+    }
+  };
+}
+exports.makeParsedUpdateHandler = makeParsedUpdateHandler;

package/highlevel/updates/parsed.d.ts

@@ -1,5 +1,5 @@
 import { ParsedUpdate } from '../types/updates/index.js';
-import { RawUpdateHandler } from './types.js';
+import { RawUpdateInfo } from './types.js';
 export interface ParsedUpdateHandlerParams {
     /**
      * When non-zero, allows the library to automatically handle Telegram
@@ -22,11 +22,5 @@ export interface ParsedUpdateHandlerParams {
     messageGroupingInterval?: number;
     /** Handler for parsed updates */
     onUpdate: (update: ParsedUpdate) => void;
-    /**
-     * Handler for raw updates.
-     *
-     * Note that this handler will be called **before** the parsed update handler.
-     */
-    onRawUpdate?: RawUpdateHandler;
 }
-export declare function makeParsedUpdateHandler(params: ParsedUpdateHandlerParams): RawUpdateHandler;
+export declare function makeParsedUpdateHandler(params: ParsedUpdateHandlerParams): (update: RawUpdateInfo) => void;

package/highlevel/updates/parsed.js

@@ -0,0 +1,43 @@
+import { timers } from "@fuman/utils";
+import { _parseUpdate } from "../types/updates/parse-update.js";
+function makeParsedUpdateHandler(params) {
+  const { messageGroupingInterval, onUpdate } = params;
+  if (!messageGroupingInterval) {
+    return (info) => {
+      const parsed = _parseUpdate(info);
+      if (parsed) onUpdate(parsed);
+    };
+  }
+  const pending = /* @__PURE__ */ new Map();
+  return (info) => {
+    const parsed = _parseUpdate(info);
+    if (parsed) {
+      if (parsed.name === "new_message" || parsed.name === "new_business_message") {
+        const group = parsed.data.groupedIdUnique;
+        if (group) {
+          const isBusiness = parsed.name === "new_business_message";
+          const pendingGroup = pending.get(group);
+          if (pendingGroup) {
+            pendingGroup[0].push(parsed.data);
+          } else {
+            const messages = [parsed.data];
+            const timeout = timers.setTimeout(() => {
+              pending.delete(group);
+              if (isBusiness) {
+                onUpdate({ name: "business_message_group", data: messages });
+              } else {
+                onUpdate({ name: "message_group", data: messages });
+              }
+            }, messageGroupingInterval);
+            pending.set(group, [messages, timeout]);
+          }
+          return;
+        }
+      }
+      onUpdate(parsed);
+    }
+  };
+}
+export {
+  makeParsedUpdateHandler
+};

package/highlevel/updates/types.cjs

@@ -0,0 +1,14 @@
+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" });
+class RawUpdateInfo {
+  constructor(update, peers) {
+    this.update = update;
+    this.peers = peers;
+  }
+}
+exports.RawUpdateInfo = RawUpdateInfo;

package/highlevel/updates/types.d.ts

@@ -1,14 +1,20 @@
+import { AsyncLock, ConditionVariable, Deque, timers } from '@fuman/utils';
 import { tl } from '@mtcute/tl';
-import { AsyncLock, ConditionVariable, Deque, EarlyTimer, Logger, SortedLinkedList, timers } from '../../utils/index.js';
+import { EarlyTimer, Logger, SortedLinkedList } from '../../utils/index.js';
 import { CurrentUserInfo } from '../storage/service/current-user.js';
 import { PeersIndex } from '../types/peers/peers-index.js';
-/**
- * Function to be called for each update.
- *
- * @param upd  The update
- * @param peers  Peers that are present in the update
- */
-export type RawUpdateHandler = (upd: tl.TypeUpdate, peers: PeersIndex) => void;
+/** Information about a raw update. */
+export declare class RawUpdateInfo {
+    /** The update */
+    readonly update: tl.TypeUpdate;
+    /** Peers that are present in the update */
+    readonly peers: PeersIndex;
+    constructor(
+    /** The update */
+    update: tl.TypeUpdate, 
+    /** Peers that are present in the update */
+    peers: PeersIndex);
+}
 /**
  * Parameters for the updates manager
  */
@@ -137,6 +143,5 @@ export interface UpdatesState {
     channelsOpened: Map<number, number>;
     log: Logger;
     stop: () => void;
-    handler: RawUpdateHandler;
     auth: CurrentUserInfo | null;
 }

package/highlevel/updates/types.js

@@ -0,0 +1,9 @@
+class RawUpdateInfo {
+  constructor(update, peers) {
+    this.update = update;
+    this.peers = peers;
+  }
+}
+export {
+  RawUpdateInfo
+};

package/highlevel/updates/utils.cjs

@@ -0,0 +1,91 @@
+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");
+function messageToUpdate(message) {
+  switch (message.peerId._) {
+    case "peerUser":
+    case "peerChat":
+      return {
+        _: "updateNewMessage",
+        message,
+        pts: 0,
+        ptsCount: 0
+      };
+    case "peerChannel":
+      return {
+        _: "updateNewChannelMessage",
+        message,
+        pts: 0,
+        ptsCount: 0
+      };
+  }
+}
+function extractChannelIdFromUpdate(upd) {
+  let res = 0;
+  if ("channelId" in upd) {
+    res = upd.channelId;
+  } else if ("message" in upd && typeof upd.message !== "string" && "peerId" in upd.message && upd.message.peerId && "channelId" in upd.message.peerId) {
+    res = upd.message.peerId.channelId;
+  }
+  if (res === 0) return void 0;
+  return res;
+}
+function toPendingUpdate(upd, peers, fromDifference = false) {
+  const channelId = extractChannelIdFromUpdate(upd) || 0;
+  const pts = "pts" in upd ? upd.pts : void 0;
+  const ptsCount = "ptsCount" in upd ? upd.ptsCount : pts ? 0 : void 0;
+  const qts = "qts" in upd ? upd.qts : void 0;
+  return {
+    update: upd,
+    channelId,
+    pts,
+    ptsBefore: pts ? pts - ptsCount : void 0,
+    qts,
+    qtsBefore: qts ? qts - 1 : void 0,
+    peers,
+    fromDifference
+  };
+}
+function isMessageEmpty(upd) {
+  return upd.message?._ === "messageEmpty";
+}
+function createDummyUpdatesContainer(updates, seq = 0) {
+  return {
+    _: "updates",
+    seq,
+    date: 0,
+    chats: [],
+    users: [],
+    updates
+  };
+}
+function createDummyUpdate(pts, ptsCount, channelId = 0) {
+  return createDummyUpdatesContainer([
+    {
+      _: "mtcute.dummyUpdate",
+      channelId,
+      pts,
+      ptsCount
+    }
+  ]);
+}
+function assertIsUpdatesGroup(ctx, upd) {
+  switch (upd._) {
+    case "updates":
+    case "updatesCombined":
+      return;
+  }
+  throw new errors.MtTypeAssertionError(ctx, "updates | updatesCombined", upd._);
+}
+exports.assertIsUpdatesGroup = assertIsUpdatesGroup;
+exports.createDummyUpdate = createDummyUpdate;
+exports.createDummyUpdatesContainer = createDummyUpdatesContainer;
+exports.extractChannelIdFromUpdate = extractChannelIdFromUpdate;
+exports.isMessageEmpty = isMessageEmpty;
+exports.messageToUpdate = messageToUpdate;
+exports.toPendingUpdate = toPendingUpdate;

package/highlevel/updates/utils.js

@@ -0,0 +1,86 @@
+import { MtTypeAssertionError } from "../../types/errors.js";
+function messageToUpdate(message) {
+  switch (message.peerId._) {
+    case "peerUser":
+    case "peerChat":
+      return {
+        _: "updateNewMessage",
+        message,
+        pts: 0,
+        ptsCount: 0
+      };
+    case "peerChannel":
+      return {
+        _: "updateNewChannelMessage",
+        message,
+        pts: 0,
+        ptsCount: 0
+      };
+  }
+}
+function extractChannelIdFromUpdate(upd) {
+  let res = 0;
+  if ("channelId" in upd) {
+    res = upd.channelId;
+  } else if ("message" in upd && typeof upd.message !== "string" && "peerId" in upd.message && upd.message.peerId && "channelId" in upd.message.peerId) {
+    res = upd.message.peerId.channelId;
+  }
+  if (res === 0) return void 0;
+  return res;
+}
+function toPendingUpdate(upd, peers, fromDifference = false) {
+  const channelId = extractChannelIdFromUpdate(upd) || 0;
+  const pts = "pts" in upd ? upd.pts : void 0;
+  const ptsCount = "ptsCount" in upd ? upd.ptsCount : pts ? 0 : void 0;
+  const qts = "qts" in upd ? upd.qts : void 0;
+  return {
+    update: upd,
+    channelId,
+    pts,
+    ptsBefore: pts ? pts - ptsCount : void 0,
+    qts,
+    qtsBefore: qts ? qts - 1 : void 0,
+    peers,
+    fromDifference
+  };
+}
+function isMessageEmpty(upd) {
+  return upd.message?._ === "messageEmpty";
+}
+function createDummyUpdatesContainer(updates, seq = 0) {
+  return {
+    _: "updates",
+    seq,
+    date: 0,
+    chats: [],
+    users: [],
+    updates
+  };
+}
+function createDummyUpdate(pts, ptsCount, channelId = 0) {
+  return createDummyUpdatesContainer([
+    {
+      _: "mtcute.dummyUpdate",
+      channelId,
+      pts,
+      ptsCount
+    }
+  ]);
+}
+function assertIsUpdatesGroup(ctx, upd) {
+  switch (upd._) {
+    case "updates":
+    case "updatesCombined":
+      return;
+  }
+  throw new MtTypeAssertionError(ctx, "updates | updatesCombined", upd._);
+}
+export {
+  assertIsUpdatesGroup,
+  createDummyUpdate,
+  createDummyUpdatesContainer,
+  extractChannelIdFromUpdate,
+  isMessageEmpty,
+  messageToUpdate,
+  toPendingUpdate
+};

package/highlevel/utils/convert-file-id.cjs

@@ -0,0 +1,236 @@
+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 Long = require("long");
+const utils = require("../../types/utils.cjs");
+const peerUtils = require("../../utils/peer-utils.cjs");
+const FileType = fileId.tdFileId.FileType;
+const EMPTY_BUFFER = new Uint8Array(0);
+function dialogPhotoToInputPeer(dialog) {
+  const markedPeerId = dialog.id;
+  const [peerType, peerId] = peerUtils.parseMarkedPeerId(markedPeerId);
+  if (peerType === "user") {
+    return {
+      _: "inputPeerUser",
+      userId: peerId,
+      accessHash: dialog.accessHash
+    };
+  } else if (peerType === "chat") {
+    return {
+      _: "inputPeerChat",
+      chatId: peerId
+    };
+  }
+  return {
+    _: "inputPeerChannel",
+    channelId: peerId,
+    accessHash: dialog.accessHash
+  };
+}
+function fileIdToInputWebFileLocation(fileId$1) {
+  if (typeof fileId$1 === "string") fileId$1 = fileId.parseFileId(fileId$1);
+  if (fileId$1.location._ !== "web") {
+    throw new fileId.tdFileId.ConversionError("inputWebFileLocation");
+  }
+  return {
+    _: "inputWebFileLocation",
+    url: fileId$1.location.url,
+    accessHash: fileId$1.location.accessHash
+  };
+}
+function fileIdToInputFileLocation(fileId$1) {
+  if (typeof fileId$1 === "string") fileId$1 = fileId.parseFileId(fileId$1);
+  const loc = fileId$1.location;
+  switch (loc._) {
+    case "web":
+      throw new fileId.tdFileId.ConversionError("InputFileLocation");
+    case "photo": {
+      switch (loc.source._) {
+        case "legacy":
+          if (!fileId$1.fileReference) {
+            throw new fileId.tdFileId.InvalidFileIdError("Expected legacy photo to have file reference");
+          }
+          return {
+            _: "inputPhotoLegacyFileLocation",
+            fileReference: fileId$1.fileReference,
+            id: loc.id,
+            accessHash: loc.accessHash,
+            volumeId: Long.ZERO,
+            localId: 0,
+            secret: loc.source.secret
+          };
+        case "thumbnail":
+          if (!fileId$1.fileReference) {
+            throw new fileId.tdFileId.InvalidFileIdError("Expected thumbnail photo to have file reference");
+          }
+          if (loc.source.fileType !== FileType.Photo && loc.source.fileType !== FileType.Thumbnail) {
+            throw new fileId.tdFileId.InvalidFileIdError("Expected a thumbnail to have a correct file type");
+          }
+          return {
+            _: loc.source.fileType === FileType.Photo ? "inputPhotoFileLocation" : "inputDocumentFileLocation",
+            fileReference: fileId$1.fileReference,
+            id: loc.id,
+            accessHash: loc.accessHash,
+            thumbSize: loc.source.thumbnailType
+          };
+        case "dialogPhoto":
+          return {
+            _: "inputPeerPhotoFileLocation",
+            big: loc.source.big,
+            peer: dialogPhotoToInputPeer(loc.source),
+            photoId: loc.id
+          };
+        case "stickerSetThumbnail":
+          return {
+            _: "inputStickerSetThumb",
+            stickerset: {
+              _: "inputStickerSetID",
+              id: loc.source.id,
+              accessHash: loc.source.accessHash
+            },
+            thumbVersion: 0
+          };
+        case "fullLegacy":
+          if (!fileId$1.fileReference) {
+            throw new fileId.tdFileId.InvalidFileIdError("Expected legacy photo to have file reference");
+          }
+          return {
+            _: "inputPhotoLegacyFileLocation",
+            fileReference: fileId$1.fileReference,
+            id: loc.id,
+            accessHash: loc.accessHash,
+            volumeId: loc.source.volumeId,
+            localId: loc.source.localId,
+            secret: loc.source.secret
+          };
+        case "dialogPhotoLegacy":
+          return {
+            _: "inputPeerPhotoFileLocationLegacy",
+            big: loc.source.big,
+            peer: dialogPhotoToInputPeer(loc.source),
+            volumeId: loc.source.volumeId,
+            localId: loc.source.localId
+          };
+        case "stickerSetThumbnailLegacy":
+          return {
+            _: "inputStickerSetThumbLegacy",
+            stickerset: {
+              _: "inputStickerSetID",
+              id: loc.source.id,
+              accessHash: loc.source.accessHash
+            },
+            volumeId: loc.source.volumeId,
+            localId: loc.source.localId
+          };
+        case "stickerSetThumbnailVersion":
+          return {
+            _: "inputStickerSetThumb",
+            stickerset: {
+              _: "inputStickerSetID",
+              id: loc.source.id,
+              accessHash: loc.source.accessHash
+            },
+            thumbVersion: loc.source.version
+          };
+        default:
+          utils.assertNever(loc.source);
+      }
+      throw new fileId.tdFileId.ConversionError("inputFileLocation");
+    }
+    case "common": {
+      if (!fileId$1.fileReference) {
+        throw new fileId.tdFileId.InvalidFileIdError("Expected common to have file reference");
+      }
+      if (fileId$1.type === FileType.Encrypted) {
+        return {
+          _: "inputEncryptedFileLocation",
+          id: loc.id,
+          accessHash: loc.accessHash
+        };
+      } else if (fileId$1.type === FileType.Secure || fileId$1.type === FileType.SecureRaw) {
+        return {
+          _: "inputSecureFileLocation",
+          id: loc.id,
+          accessHash: loc.accessHash
+        };
+      }
+      return {
+        _: "inputDocumentFileLocation",
+        fileReference: fileId$1.fileReference,
+        id: loc.id,
+        accessHash: loc.accessHash,
+        thumbSize: ""
+      };
+    }
+    default:
+      utils.assertNever();
+  }
+}
+function fileIdToInputDocument(fileId$1) {
+  if (typeof fileId$1 === "string") fileId$1 = fileId.parseFileId(fileId$1);
+  if (fileId$1.location._ !== "common" || fileId$1.type === FileType.Secure || fileId$1.type === FileType.SecureRaw || fileId$1.type === FileType.Encrypted) {
+    throw new fileId.tdFileId.ConversionError("inputDocument");
+  }
+  let fileRef = fileId$1.fileReference;
+  if (!fileRef) {
+    if (fileId$1.type === FileType.Sticker) {
+      fileRef = EMPTY_BUFFER;
+    } else {
+      throw new fileId.tdFileId.InvalidFileIdError("Expected document to have file reference");
+    }
+  }
+  return {
+    _: "inputDocument",
+    fileReference: fileRef,
+    id: fileId$1.location.id,
+    accessHash: fileId$1.location.accessHash
+  };
+}
+function fileIdToInputPhoto(fileId$1) {
+  if (typeof fileId$1 === "string") fileId$1 = fileId.parseFileId(fileId$1);
+  if (fileId$1.location._ !== "photo") {
+    throw new fileId.tdFileId.ConversionError("inputPhoto");
+  }
+  if (!fileId$1.fileReference) {
+    throw new fileId.tdFileId.InvalidFileIdError("Expected photo to have file reference");
+  }
+  return {
+    _: "inputPhoto",
+    fileReference: fileId$1.fileReference,
+    id: fileId$1.location.id,
+    accessHash: fileId$1.location.accessHash
+  };
+}
+function fileIdToEncryptedFile(fileId$1) {
+  if (typeof fileId$1 === "string") fileId$1 = fileId.parseFileId(fileId$1);
+  if (fileId$1.location._ !== "common" || fileId$1.type !== FileType.Encrypted) {
+    throw new fileId.tdFileId.ConversionError("inputEncryptedFile");
+  }
+  return {
+    _: "inputEncryptedFile",
+    id: fileId$1.location.id,
+    accessHash: fileId$1.location.accessHash
+  };
+}
+function fileIdToSecureFile(fileId$1) {
+  if (typeof fileId$1 === "string") fileId$1 = fileId.parseFileId(fileId$1);
+  if (fileId$1.location._ !== "common" || fileId$1.type !== FileType.Secure && fileId$1.type !== FileType.SecureRaw) {
+    throw new fileId.tdFileId.ConversionError("inputSecureFile");
+  }
+  return {
+    _: "inputSecureFile",
+    id: fileId$1.location.id,
+    accessHash: fileId$1.location.accessHash
+  };
+}
+exports.fileIdToEncryptedFile = fileIdToEncryptedFile;
+exports.fileIdToInputDocument = fileIdToInputDocument;
+exports.fileIdToInputFileLocation = fileIdToInputFileLocation;
+exports.fileIdToInputPhoto = fileIdToInputPhoto;
+exports.fileIdToInputWebFileLocation = fileIdToInputWebFileLocation;
+exports.fileIdToSecureFile = fileIdToSecureFile;

package/highlevel/utils/convert-file-id.d.ts

@@ -1,5 +1,5 @@
-import { tdFileId as td } from '@mtcute/file-id';
 import { tl } from '@mtcute/tl';
+import { tdFileId as td } from '@mtcute/file-id';
 type FileId = td.RawFullRemoteFileLocation;
 /**
  * Convert a file ID or {@link tdFileId.RawFullRemoteFileLocation}