@mtcute/core 0.17.0 → 0.18.0-rc.5

package/highlevel/utils/peer-utils.js

@@ -0,0 +1,132 @@
+import { tl } from "@mtcute/tl";
+import { assertNever } from "../../types/utils.js";
+import { MtInvalidPeerTypeError } from "../types/errors.js";
+const INVITE_LINK_REGEX = /^(?:https?:\/\/)?(?:www\.)?t(?:elegram)?\.(?:org|me|dog)\/(?:joinchat\/|\+)([\w-]+)$/i;
+function toInputPeer(res) {
+  if (tl.isAnyInputPeer(res)) return res;
+  switch (res._) {
+    case "inputChannelEmpty":
+    case "inputUserEmpty":
+      return { _: "inputPeerEmpty" };
+    case "inputUser":
+      return {
+        _: "inputPeerUser",
+        userId: res.userId,
+        accessHash: res.accessHash
+      };
+    case "inputUserSelf":
+      return { _: "inputPeerSelf" };
+    case "inputChannel":
+      return {
+        _: "inputPeerChannel",
+        channelId: res.channelId,
+        accessHash: res.accessHash
+      };
+    case "inputChannelFromMessage":
+      return {
+        _: "inputPeerChannelFromMessage",
+        channelId: res.channelId,
+        msgId: res.msgId,
+        peer: res.peer
+      };
+    case "inputUserFromMessage":
+      return {
+        _: "inputPeerUserFromMessage",
+        userId: res.userId,
+        msgId: res.msgId,
+        peer: res.peer
+      };
+    default:
+      assertNever();
+  }
+}
+function toInputUser(res, input) {
+  if (tl.isAnyInputUser(res)) return res;
+  switch (res._) {
+    case "inputPeerSelf":
+      return { _: "inputUserSelf" };
+    case "inputPeerUser":
+      return {
+        _: "inputUser",
+        userId: res.userId,
+        accessHash: res.accessHash
+      };
+    case "inputPeerUserFromMessage":
+      return {
+        _: "inputUserFromMessage",
+        userId: res.userId,
+        msgId: res.msgId,
+        peer: res.peer
+      };
+  }
+  throw new MtInvalidPeerTypeError(input ?? res, "user");
+}
+function toInputChannel(res, input) {
+  if (tl.isAnyInputChannel(res)) return res;
+  switch (res._) {
+    case "inputPeerChannel":
+      return {
+        _: "inputChannel",
+        channelId: res.channelId,
+        accessHash: res.accessHash
+      };
+    case "inputPeerChannelFromMessage":
+      return {
+        _: "inputChannelFromMessage",
+        channelId: res.channelId,
+        msgId: res.msgId,
+        peer: res.peer
+      };
+  }
+  throw new MtInvalidPeerTypeError(input ?? res, "channel");
+}
+function isInputPeerUser(obj) {
+  switch (obj._) {
+    case "inputPeerUser":
+    case "inputPeerUserFromMessage":
+    case "inputPeerSelf":
+      return true;
+  }
+  return false;
+}
+function isInputPeerChannel(obj) {
+  switch (obj._) {
+    case "inputPeerChannel":
+    case "inputPeerChannelFromMessage":
+      return true;
+  }
+  return false;
+}
+function isInputPeerChat(obj) {
+  return obj._ === "inputPeerChat";
+}
+function inputPeerToPeer(inp) {
+  switch (inp._) {
+    case "inputPeerUser":
+    case "inputPeerUserFromMessage":
+      return { _: "peerUser", userId: inp.userId };
+    case "inputPeerChannel":
+    case "inputPeerChannelFromMessage":
+      return { _: "peerChannel", channelId: inp.channelId };
+    case "inputPeerChat":
+      return { _: "peerChat", chatId: inp.chatId };
+    default:
+      throw new MtInvalidPeerTypeError(inp, `Cannot convert ${inp._} to peer`);
+  }
+}
+function extractUsernames(obj) {
+  if (obj.usernames?.length) return obj.usernames.map((x) => x.username.toLowerCase());
+  if (obj.username) return [obj.username.toLowerCase()];
+  return [];
+}
+export {
+  INVITE_LINK_REGEX,
+  extractUsernames,
+  inputPeerToPeer,
+  isInputPeerChannel,
+  isInputPeerChat,
+  isInputPeerUser,
+  toInputChannel,
+  toInputPeer,
+  toInputUser
+};

package/highlevel/utils/query-batcher.cjs

@@ -0,0 +1,124 @@
+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");
+function batchedQuery(params) {
+  const { inputKey, outputKey, fetch, maxBatchSize = Infinity, maxConcurrent = 1, retrySingleOnError } = params;
+  const symbol = Symbol("batchedQueryState");
+  function getState(client_) {
+    const client = client_;
+    if (!client[symbol]) {
+      client[symbol] = {
+        waiters: /* @__PURE__ */ new Map(),
+        fetchingKeys: /* @__PURE__ */ new Set(),
+        retryQueue: new utils.Deque(),
+        numRunning: 0
+      };
+    }
+    return client[symbol];
+  }
+  function addWaiter(client, waiters, item) {
+    const key = inputKey(item, client);
+    let arr = waiters.get(key);
+    if (!arr) {
+      arr = [];
+      waiters.set(key, arr);
+    }
+    return new Promise((resolve, reject) => {
+      arr.push([item, resolve, reject]);
+    });
+  }
+  function popWaiters(waiters, key) {
+    const arr = waiters.get(key);
+    if (!arr) return [];
+    waiters.delete(key);
+    return arr;
+  }
+  function startLoops(client, state) {
+    for (let i = state.numRunning; i <= maxConcurrent; i++) {
+      processPending(client, state);
+    }
+  }
+  function processPending(client, state) {
+    const { waiters, fetchingKeys, retryQueue } = state;
+    if (state.numRunning >= maxConcurrent) return;
+    const request = [];
+    const requestKeys = [];
+    let isRetryRequest = false;
+    if (retryQueue.length > 0) {
+      isRetryRequest = true;
+      const it = retryQueue.popFront();
+      request.push(it);
+      const key = inputKey(it, client);
+      requestKeys.push(key);
+      fetchingKeys.add(key);
+    } else {
+      for (const it of waiters.keys()) {
+        if (fetchingKeys.has(it)) continue;
+        request.push(waiters.get(it)[0][0]);
+        requestKeys.push(it);
+        fetchingKeys.add(it);
+        if (request.length === maxBatchSize) break;
+      }
+      if (request.length === 0) return;
+    }
+    state.numRunning += 1;
+    fetch(client, request).then((res) => {
+      const receivedKeys = /* @__PURE__ */ new Set();
+      for (const it of res) {
+        const key = outputKey(it, client);
+        receivedKeys.add(key);
+        for (const waiter of popWaiters(waiters, key)) {
+          waiter[1](it);
+        }
+        fetchingKeys.delete(key);
+      }
+      for (const key of requestKeys) {
+        if (!receivedKeys.has(key)) {
+          for (const waiter of popWaiters(waiters, key)) {
+            waiter[1](null);
+          }
+          fetchingKeys.delete(key);
+        }
+      }
+    }).catch((err) => {
+      if (retrySingleOnError && !isRetryRequest) {
+        const retry = retrySingleOnError(request, err);
+        if (retry === true) {
+          for (const it of request) {
+            retryQueue.pushBack(it);
+          }
+          return;
+        } else if (Array.isArray(retry)) {
+          for (const req of retry) {
+            const requestKeysIdx = request.indexOf(req);
+            if (requestKeysIdx < 0) continue;
+            retryQueue.pushBack(req);
+            request.splice(requestKeysIdx, 1);
+            requestKeys.splice(requestKeysIdx, 1);
+          }
+        }
+      }
+      for (const key of requestKeys) {
+        for (const waiter of popWaiters(waiters, key)) {
+          waiter[2](err);
+        }
+        fetchingKeys.delete(key);
+      }
+    }).then(() => {
+      state.numRunning -= 1;
+      if (waiters.size > 0) processPending(client, state);
+    });
+  }
+  return function(client, item) {
+    const state = getState(client);
+    const promise = addWaiter(client, state.waiters, item);
+    startLoops(client, state);
+    return promise;
+  };
+}
+exports.batchedQuery = batchedQuery;

package/highlevel/utils/query-batcher.js

@@ -0,0 +1,119 @@
+import { Deque } from "@fuman/utils";
+function batchedQuery(params) {
+  const { inputKey, outputKey, fetch, maxBatchSize = Infinity, maxConcurrent = 1, retrySingleOnError } = params;
+  const symbol = Symbol("batchedQueryState");
+  function getState(client_) {
+    const client = client_;
+    if (!client[symbol]) {
+      client[symbol] = {
+        waiters: /* @__PURE__ */ new Map(),
+        fetchingKeys: /* @__PURE__ */ new Set(),
+        retryQueue: new Deque(),
+        numRunning: 0
+      };
+    }
+    return client[symbol];
+  }
+  function addWaiter(client, waiters, item) {
+    const key = inputKey(item, client);
+    let arr = waiters.get(key);
+    if (!arr) {
+      arr = [];
+      waiters.set(key, arr);
+    }
+    return new Promise((resolve, reject) => {
+      arr.push([item, resolve, reject]);
+    });
+  }
+  function popWaiters(waiters, key) {
+    const arr = waiters.get(key);
+    if (!arr) return [];
+    waiters.delete(key);
+    return arr;
+  }
+  function startLoops(client, state) {
+    for (let i = state.numRunning; i <= maxConcurrent; i++) {
+      processPending(client, state);
+    }
+  }
+  function processPending(client, state) {
+    const { waiters, fetchingKeys, retryQueue } = state;
+    if (state.numRunning >= maxConcurrent) return;
+    const request = [];
+    const requestKeys = [];
+    let isRetryRequest = false;
+    if (retryQueue.length > 0) {
+      isRetryRequest = true;
+      const it = retryQueue.popFront();
+      request.push(it);
+      const key = inputKey(it, client);
+      requestKeys.push(key);
+      fetchingKeys.add(key);
+    } else {
+      for (const it of waiters.keys()) {
+        if (fetchingKeys.has(it)) continue;
+        request.push(waiters.get(it)[0][0]);
+        requestKeys.push(it);
+        fetchingKeys.add(it);
+        if (request.length === maxBatchSize) break;
+      }
+      if (request.length === 0) return;
+    }
+    state.numRunning += 1;
+    fetch(client, request).then((res) => {
+      const receivedKeys = /* @__PURE__ */ new Set();
+      for (const it of res) {
+        const key = outputKey(it, client);
+        receivedKeys.add(key);
+        for (const waiter of popWaiters(waiters, key)) {
+          waiter[1](it);
+        }
+        fetchingKeys.delete(key);
+      }
+      for (const key of requestKeys) {
+        if (!receivedKeys.has(key)) {
+          for (const waiter of popWaiters(waiters, key)) {
+            waiter[1](null);
+          }
+          fetchingKeys.delete(key);
+        }
+      }
+    }).catch((err) => {
+      if (retrySingleOnError && !isRetryRequest) {
+        const retry = retrySingleOnError(request, err);
+        if (retry === true) {
+          for (const it of request) {
+            retryQueue.pushBack(it);
+          }
+          return;
+        } else if (Array.isArray(retry)) {
+          for (const req of retry) {
+            const requestKeysIdx = request.indexOf(req);
+            if (requestKeysIdx < 0) continue;
+            retryQueue.pushBack(req);
+            request.splice(requestKeysIdx, 1);
+            requestKeys.splice(requestKeysIdx, 1);
+          }
+        }
+      }
+      for (const key of requestKeys) {
+        for (const waiter of popWaiters(waiters, key)) {
+          waiter[2](err);
+        }
+        fetchingKeys.delete(key);
+      }
+    }).then(() => {
+      state.numRunning -= 1;
+      if (waiters.size > 0) processPending(client, state);
+    });
+  }
+  return function(client, item) {
+    const state = getState(client);
+    const promise = addWaiter(client, state.waiters, item);
+    startLoops(client, state);
+    return promise;
+  };
+}
+export {
+  batchedQuery
+};

package/highlevel/utils/rps-meter.cjs

@@ -0,0 +1,39 @@
+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");
+class RpsMeter {
+  constructor(size = 500, time = 5e3) {
+    this.size = size;
+    if (typeof process === "undefined" || !process.hrtime.bigint) {
+      throw new Error("RPS meter is not supported on this platform");
+    }
+    this._hits = new utils.Deque(void 0, { capacity: size });
+    this.time = BigInt(time) * BigInt(1e6);
+  }
+  _hits;
+  time;
+  hit() {
+    this._hits.pushBack(process.hrtime.bigint());
+  }
+  getRps() {
+    if (!this._hits.length) return 0;
+    const now = process.hrtime.bigint();
+    const window = now - this.time;
+    const iter = this._hits[Symbol.iterator]();
+    let first = iter.next();
+    let idx = 0;
+    while (!first.done && first.value < window) {
+      first = iter.next();
+      idx += 1;
+    }
+    if (!first.value) return 0;
+    const hits = this._hits.length - idx;
+    return hits * 1e9 / Number(now - first.value);
+  }
+}
+exports.RpsMeter = RpsMeter;

package/highlevel/utils/rps-meter.d.ts

@@ -1,4 +1,4 @@
-import { Deque } from '../../utils/deque.js';
+import { Deque } from '@fuman/utils';
 export declare class RpsMeter {
     readonly size: number;
     _hits: Deque<bigint>;

package/highlevel/utils/rps-meter.js

@@ -0,0 +1,34 @@
+import { Deque } from "@fuman/utils";
+class RpsMeter {
+  constructor(size = 500, time = 5e3) {
+    this.size = size;
+    if (typeof process === "undefined" || !process.hrtime.bigint) {
+      throw new Error("RPS meter is not supported on this platform");
+    }
+    this._hits = new Deque(void 0, { capacity: size });
+    this.time = BigInt(time) * BigInt(1e6);
+  }
+  _hits;
+  time;
+  hit() {
+    this._hits.pushBack(process.hrtime.bigint());
+  }
+  getRps() {
+    if (!this._hits.length) return 0;
+    const now = process.hrtime.bigint();
+    const window = now - this.time;
+    const iter = this._hits[Symbol.iterator]();
+    let first = iter.next();
+    let idx = 0;
+    while (!first.done && first.value < window) {
+      first = iter.next();
+      idx += 1;
+    }
+    if (!first.value) return 0;
+    const hits = this._hits.length - idx;
+    return hits * 1e9 / Number(now - first.value);
+  }
+}
+export {
+  RpsMeter
+};

package/highlevel/utils/stream-utils.cjs

@@ -0,0 +1,19 @@
+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");
+async function streamToBuffer(stream) {
+  const chunks = [];
+  const reader = stream.getReader();
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    chunks.push(value);
+  }
+  return utils.u8.concat(chunks);
+}
+exports.streamToBuffer = streamToBuffer;

package/highlevel/utils/stream-utils.d.ts

@@ -1,6 +1 @@
-export declare function bufferToStream(buf: Uint8Array): ReadableStream<Uint8Array>;
 export declare function streamToBuffer(stream: ReadableStream<Uint8Array>): Promise<Uint8Array>;
-export declare function createChunkedReader(stream: ReadableStream<Uint8Array>, chunkSize: number): {
-    ended: () => boolean;
-    read: () => Promise<Uint8Array | null>;
-};

package/highlevel/utils/stream-utils.js

@@ -0,0 +1,14 @@
+import { u8 } from "@fuman/utils";
+async function streamToBuffer(stream) {
+  const chunks = [];
+  const reader = stream.getReader();
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    chunks.push(value);
+  }
+  return u8.concat(chunks);
+}
+export {
+  streamToBuffer
+};

package/highlevel/utils/string-session.cjs

@@ -0,0 +1,96 @@
+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 tlRuntime = require("@mtcute/tl-runtime");
+const dcs = require("../../utils/dcs.cjs");
+const errors = require("../../types/errors.cjs");
+function writeStringSession(data) {
+  const writer = tlRuntime.TlBinaryWriter.manual(512);
+  const version = data.version;
+  if (version !== 3) {
+    throw new errors.MtArgumentError(`Unsupported string session version: ${version}`);
+  }
+  let flags = 0;
+  if (data.self) {
+    flags |= 1;
+  }
+  writer.uint8View[0] = version;
+  writer.pos += 1;
+  if (data.primaryDcs.media !== data.primaryDcs.main) {
+    flags |= 4;
+  }
+  writer.int(flags);
+  writer.bytes(dcs.serializeBasicDcOption(data.primaryDcs.main));
+  if (data.primaryDcs.media !== data.primaryDcs.main) {
+    writer.bytes(dcs.serializeBasicDcOption(data.primaryDcs.media));
+  }
+  if (data.self) {
+    writer.int53(data.self.userId);
+    writer.boolean(data.self.isBot);
+  }
+  writer.bytes(data.authKey);
+  return utils.base64.encode(writer.result(), true);
+}
+function readStringSession(data) {
+  if (typeof data !== "string") {
+    return {
+      version: 3,
+      primaryDcs: data.primaryDcs ?? (data.testMode ? dcs.defaultTestDc : dcs.defaultProductionDc),
+      self: data.self ?? null,
+      authKey: data.authKey
+    };
+  }
+  const buf = utils.base64.decode(data, true);
+  const version = buf[0];
+  if (version !== 3) {
+    throw new Error(`Invalid session string (version = ${version})`);
+  }
+  const reader = tlRuntime.TlBinaryReader.manual(buf, 1);
+  const flags = reader.int();
+  const hasSelf = flags & 1;
+  const testModeOld = Boolean(flags & 2);
+  const hasMedia = version >= 2 && Boolean(flags & 4);
+  const primaryDc = dcs.parseBasicDcOption(reader.bytes());
+  if (primaryDc === null) {
+    throw new errors.MtArgumentError("Invalid session string (failed to parse primaryDc)");
+  }
+  const primaryMediaDc = hasMedia ? dcs.parseBasicDcOption(reader.bytes()) : primaryDc;
+  if (primaryMediaDc === null) {
+    throw new errors.MtArgumentError("Invalid session string (failed to parse primaryMediaDc)");
+  }
+  if (testModeOld) {
+    primaryDc.testMode = true;
+    primaryMediaDc.testMode = true;
+  } else if (primaryDc.testMode !== primaryMediaDc.testMode) {
+    throw new errors.MtArgumentError("Primary DC and primary media DC must have the same test mode flag");
+  }
+  let self = null;
+  if (hasSelf) {
+    const selfId = reader.int53();
+    const selfBot = reader.boolean();
+    self = {
+      userId: selfId,
+      isBot: selfBot,
+      // todo: we should make sure we fetch this from the server at first start
+      isPremium: false,
+      usernames: []
+    };
+  }
+  const key = reader.bytes();
+  return {
+    version,
+    primaryDcs: {
+      main: primaryDc,
+      media: primaryMediaDc
+    },
+    self,
+    authKey: key
+  };
+}
+exports.readStringSession = readStringSession;
+exports.writeStringSession = writeStringSession;

package/highlevel/utils/string-session.d.ts

@@ -1,11 +1,16 @@
 import { DcOptions } from '../../utils/dcs.js';
 import { CurrentUserInfo } from '../storage/service/current-user.js';
+export interface InputStringSessionData {
+    primaryDcs?: DcOptions;
+    testMode?: boolean;
+    self?: CurrentUserInfo | null;
+    authKey: Uint8Array;
+}
 export interface StringSessionData {
     version: number;
-    testMode: boolean;
     primaryDcs: DcOptions;
     self?: CurrentUserInfo | null;
     authKey: Uint8Array;
 }
 export declare function writeStringSession(data: StringSessionData): string;
-export declare function readStringSession(data: string): StringSessionData;
+export declare function readStringSession(data: string | InputStringSessionData): StringSessionData;