@mtcute/core 0.17.0 → 0.18.0-rc.5

package/highlevel/utils/string-session.js

@@ -0,0 +1,91 @@
+import { base64 } from "@fuman/utils";
+import { TlBinaryWriter, TlBinaryReader } from "@mtcute/tl-runtime";
+import { serializeBasicDcOption, defaultTestDc, defaultProductionDc, parseBasicDcOption } from "../../utils/dcs.js";
+import { MtArgumentError } from "../../types/errors.js";
+function writeStringSession(data) {
+  const writer = TlBinaryWriter.manual(512);
+  const version = data.version;
+  if (version !== 3) {
+    throw new 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(serializeBasicDcOption(data.primaryDcs.main));
+  if (data.primaryDcs.media !== data.primaryDcs.main) {
+    writer.bytes(serializeBasicDcOption(data.primaryDcs.media));
+  }
+  if (data.self) {
+    writer.int53(data.self.userId);
+    writer.boolean(data.self.isBot);
+  }
+  writer.bytes(data.authKey);
+  return base64.encode(writer.result(), true);
+}
+function readStringSession(data) {
+  if (typeof data !== "string") {
+    return {
+      version: 3,
+      primaryDcs: data.primaryDcs ?? (data.testMode ? defaultTestDc : defaultProductionDc),
+      self: data.self ?? null,
+      authKey: data.authKey
+    };
+  }
+  const buf = base64.decode(data, true);
+  const version = buf[0];
+  if (version !== 3) {
+    throw new Error(`Invalid session string (version = ${version})`);
+  }
+  const reader = 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 = parseBasicDcOption(reader.bytes());
+  if (primaryDc === null) {
+    throw new MtArgumentError("Invalid session string (failed to parse primaryDc)");
+  }
+  const primaryMediaDc = hasMedia ? parseBasicDcOption(reader.bytes()) : primaryDc;
+  if (primaryMediaDc === null) {
+    throw new MtArgumentError("Invalid session string (failed to parse primaryMediaDc)");
+  }
+  if (testModeOld) {
+    primaryDc.testMode = true;
+    primaryMediaDc.testMode = true;
+  } else if (primaryDc.testMode !== primaryMediaDc.testMode) {
+    throw new 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
+  };
+}
+export {
+  readStringSession,
+  writeStringSession
+};

package/highlevel/utils/voice-utils.cjs

@@ -0,0 +1,41 @@
+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 decodeWaveform(wf) {
+  const bitsCount = wf.length * 8;
+  const valuesCount = ~~(bitsCount / 5);
+  if (!valuesCount) return [];
+  const lastIdx = valuesCount - 1;
+  const result = [];
+  const dv = utils.typed.toDataView(wf);
+  for (let i = 0, j = 0; i < lastIdx; i++, j += 5) {
+    const byteIdx = ~~(j / 8);
+    const bitShift = j % 8;
+    result[i] = dv.getUint16(byteIdx, true) >> bitShift & 31;
+  }
+  const lastByteIdx = ~~(lastIdx * 5 / 8);
+  const lastBitShift = lastIdx * 5 % 8;
+  const lastValue = lastByteIdx === wf.length - 1 ? wf[lastByteIdx] : dv.getUint16(lastByteIdx, true);
+  result[lastIdx] = lastValue >> lastBitShift & 31;
+  return result;
+}
+function encodeWaveform(wf) {
+  const bitsCount = wf.length * 5;
+  const bytesCount = ~~((bitsCount + 7) / 8);
+  const result = utils.u8.alloc(bytesCount + 1);
+  const dv = utils.typed.toDataView(result);
+  for (let i = 0, j = 0; i < wf.length; i++, j += 5) {
+    const byteIdx = ~~(j / 8);
+    const bitShift = j % 8;
+    const value = (wf[i] & 31) << bitShift;
+    dv.setUint16(byteIdx, dv.getUint16(byteIdx, true) | value, true);
+  }
+  return result.slice(0, bytesCount);
+}
+exports.decodeWaveform = decodeWaveform;
+exports.encodeWaveform = encodeWaveform;

package/highlevel/utils/voice-utils.js

@@ -0,0 +1,36 @@
+import { typed, u8 } from "@fuman/utils";
+function decodeWaveform(wf) {
+  const bitsCount = wf.length * 8;
+  const valuesCount = ~~(bitsCount / 5);
+  if (!valuesCount) return [];
+  const lastIdx = valuesCount - 1;
+  const result = [];
+  const dv = typed.toDataView(wf);
+  for (let i = 0, j = 0; i < lastIdx; i++, j += 5) {
+    const byteIdx = ~~(j / 8);
+    const bitShift = j % 8;
+    result[i] = dv.getUint16(byteIdx, true) >> bitShift & 31;
+  }
+  const lastByteIdx = ~~(lastIdx * 5 / 8);
+  const lastBitShift = lastIdx * 5 % 8;
+  const lastValue = lastByteIdx === wf.length - 1 ? wf[lastByteIdx] : dv.getUint16(lastByteIdx, true);
+  result[lastIdx] = lastValue >> lastBitShift & 31;
+  return result;
+}
+function encodeWaveform(wf) {
+  const bitsCount = wf.length * 5;
+  const bytesCount = ~~((bitsCount + 7) / 8);
+  const result = u8.alloc(bytesCount + 1);
+  const dv = typed.toDataView(result);
+  for (let i = 0, j = 0; i < wf.length; i++, j += 5) {
+    const byteIdx = ~~(j / 8);
+    const bitShift = j % 8;
+    const value = (wf[i] & 31) << bitShift;
+    dv.setUint16(byteIdx, dv.getUint16(byteIdx, true) | value, true);
+  }
+  return result.slice(0, bytesCount);
+}
+export {
+  decodeWaveform,
+  encodeWaveform
+};

package/highlevel/worker/app-config.cjs

@@ -0,0 +1,18 @@
+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 AppConfigManagerProxy {
+  constructor(invoker) {
+    this.invoker = invoker;
+    const bind = invoker.makeBinder("app-config");
+    this.get = bind("get");
+    this.getField = bind("getField");
+  }
+  get;
+  getField;
+}
+exports.AppConfigManagerProxy = AppConfigManagerProxy;

package/highlevel/worker/app-config.js

@@ -0,0 +1,13 @@
+class AppConfigManagerProxy {
+  constructor(invoker) {
+    this.invoker = invoker;
+    const bind = invoker.makeBinder("app-config");
+    this.get = bind("get");
+    this.getField = bind("getField");
+  }
+  get;
+  getField;
+}
+export {
+  AppConfigManagerProxy
+};

package/highlevel/worker/errors.cjs

@@ -0,0 +1,118 @@
+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 tl = require("@mtcute/tl");
+const errors$1 = require("../../types/errors.cjs");
+const errors = require("../types/errors.cjs");
+function serializeError(error) {
+  if (!(error instanceof Error)) return { name: "Error", message: String(error) };
+  const res = {
+    name: "Error",
+    message: error.message,
+    stack: error.stack
+  };
+  const ctor = error.constructor;
+  if (ctor === errors$1.MtTypeAssertionError) {
+    const _error = error;
+    res.name = "MtTypeAssertionError";
+    res.custom = {
+      context: _error.context,
+      expected: _error.expected,
+      actual: _error.actual
+    };
+  } else if (ctor === errors$1.MtTimeoutError) {
+    const _error = error;
+    res.name = "MtTimeoutError";
+    res.custom = {
+      timeout: _error.timeout
+    };
+  } else if (ctor === errors.MtMessageNotFoundError) {
+    const _error = error;
+    res.name = "MtMessageNotFoundError";
+    res.custom = {
+      peerId: _error.peerId,
+      messageId: _error.messageId,
+      context: _error.context
+    };
+  } else if (ctor === tl.tl.RpcError) {
+    res.name = "RpcError";
+    res.custom = { ...error };
+  } else if (ctor === errors$1.MtArgumentError) {
+    res.name = "MtArgumentError";
+  } else if (ctor === errors$1.MtSecurityError) {
+    res.name = "MtSecurityError";
+  } else if (ctor === errors$1.MtUnsupportedError) {
+    res.name = "MtUnsupportedError";
+  } else if (ctor === errors.MtPeerNotFoundError) {
+    res.name = "MtPeerNotFoundError";
+  } else if (ctor === errors.MtInvalidPeerTypeError) {
+    res.name = "MtInvalidPeerTypeError";
+  } else if (ctor === errors.MtEmptyError) {
+    res.name = "MtEmptyError";
+  } else if (ctor instanceof errors$1.MtcuteError) {
+    res.name = "MtcuteError";
+  }
+  return res;
+}
+function deserializeError(error) {
+  let err2;
+  switch (error.name) {
+    case "MtTypeAssertionError": {
+      const custom = error.custom;
+      err2 = new errors$1.MtTypeAssertionError(custom.context, custom.expected, custom.actual);
+      break;
+    }
+    case "MtTimeoutError": {
+      const custom = error.custom;
+      err2 = new errors$1.MtTimeoutError(custom.timeout);
+      break;
+    }
+    case "MtMessageNotFoundError": {
+      const custom = error.custom;
+      err2 = new errors.MtMessageNotFoundError(custom.peerId, custom.messageId, custom.context);
+      break;
+    }
+    case "RpcError": {
+      const custom = error.custom;
+      err2 = new tl.tl.RpcError(custom.code, custom.text);
+      err2.message = error.message;
+      for (const key in custom) {
+        if (key === "code" || key === "text") continue;
+        err2[key] = custom[key];
+      }
+      break;
+    }
+    case "MtArgumentError":
+      err2 = new errors$1.MtArgumentError();
+      break;
+    case "MtSecurityError":
+      err2 = new errors$1.MtSecurityError();
+      break;
+    case "MtUnsupportedError":
+      err2 = new errors$1.MtUnsupportedError();
+      break;
+    case "MtPeerNotFoundError":
+      err2 = new errors.MtPeerNotFoundError();
+      break;
+    case "MtInvalidPeerTypeError":
+      err2 = new errors.MtInvalidPeerTypeError("", "");
+      err2.message = error.message;
+      break;
+    case "MtEmptyError":
+      err2 = new errors.MtEmptyError();
+      break;
+    case "MtcuteError":
+      err2 = new errors$1.MtcuteError();
+      break;
+    default:
+      err2 = new Error(error.message);
+  }
+  err2.stack = error.stack;
+  return err2;
+}
+exports.deserializeError = deserializeError;
+exports.serializeError = serializeError;

package/highlevel/worker/errors.js

@@ -0,0 +1,113 @@
+import { tl } from "@mtcute/tl";
+import { MtUnsupportedError, MtSecurityError, MtArgumentError, MtTimeoutError, MtTypeAssertionError, MtcuteError } from "../../types/errors.js";
+import { MtEmptyError, MtInvalidPeerTypeError, MtPeerNotFoundError, MtMessageNotFoundError } from "../types/errors.js";
+function serializeError(error) {
+  if (!(error instanceof Error)) return { name: "Error", message: String(error) };
+  const res = {
+    name: "Error",
+    message: error.message,
+    stack: error.stack
+  };
+  const ctor = error.constructor;
+  if (ctor === MtTypeAssertionError) {
+    const _error = error;
+    res.name = "MtTypeAssertionError";
+    res.custom = {
+      context: _error.context,
+      expected: _error.expected,
+      actual: _error.actual
+    };
+  } else if (ctor === MtTimeoutError) {
+    const _error = error;
+    res.name = "MtTimeoutError";
+    res.custom = {
+      timeout: _error.timeout
+    };
+  } else if (ctor === MtMessageNotFoundError) {
+    const _error = error;
+    res.name = "MtMessageNotFoundError";
+    res.custom = {
+      peerId: _error.peerId,
+      messageId: _error.messageId,
+      context: _error.context
+    };
+  } else if (ctor === tl.RpcError) {
+    res.name = "RpcError";
+    res.custom = { ...error };
+  } else if (ctor === MtArgumentError) {
+    res.name = "MtArgumentError";
+  } else if (ctor === MtSecurityError) {
+    res.name = "MtSecurityError";
+  } else if (ctor === MtUnsupportedError) {
+    res.name = "MtUnsupportedError";
+  } else if (ctor === MtPeerNotFoundError) {
+    res.name = "MtPeerNotFoundError";
+  } else if (ctor === MtInvalidPeerTypeError) {
+    res.name = "MtInvalidPeerTypeError";
+  } else if (ctor === MtEmptyError) {
+    res.name = "MtEmptyError";
+  } else if (ctor instanceof MtcuteError) {
+    res.name = "MtcuteError";
+  }
+  return res;
+}
+function deserializeError(error) {
+  let err2;
+  switch (error.name) {
+    case "MtTypeAssertionError": {
+      const custom = error.custom;
+      err2 = new MtTypeAssertionError(custom.context, custom.expected, custom.actual);
+      break;
+    }
+    case "MtTimeoutError": {
+      const custom = error.custom;
+      err2 = new MtTimeoutError(custom.timeout);
+      break;
+    }
+    case "MtMessageNotFoundError": {
+      const custom = error.custom;
+      err2 = new MtMessageNotFoundError(custom.peerId, custom.messageId, custom.context);
+      break;
+    }
+    case "RpcError": {
+      const custom = error.custom;
+      err2 = new tl.RpcError(custom.code, custom.text);
+      err2.message = error.message;
+      for (const key in custom) {
+        if (key === "code" || key === "text") continue;
+        err2[key] = custom[key];
+      }
+      break;
+    }
+    case "MtArgumentError":
+      err2 = new MtArgumentError();
+      break;
+    case "MtSecurityError":
+      err2 = new MtSecurityError();
+      break;
+    case "MtUnsupportedError":
+      err2 = new MtUnsupportedError();
+      break;
+    case "MtPeerNotFoundError":
+      err2 = new MtPeerNotFoundError();
+      break;
+    case "MtInvalidPeerTypeError":
+      err2 = new MtInvalidPeerTypeError("", "");
+      err2.message = error.message;
+      break;
+    case "MtEmptyError":
+      err2 = new MtEmptyError();
+      break;
+    case "MtcuteError":
+      err2 = new MtcuteError();
+      break;
+    default:
+      err2 = new Error(error.message);
+  }
+  err2.stack = error.stack;
+  return err2;
+}
+export {
+  deserializeError,
+  serializeError
+};

package/highlevel/worker/invoker.cjs

@@ -0,0 +1,71 @@
+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 errors = require("./errors.cjs");
+const protocol = require("./protocol.cjs");
+class WorkerInvoker {
+  constructor(send) {
+    this.send = send;
+  }
+  _nextId = 0;
+  _pending = /* @__PURE__ */ new Map();
+  _invoke(target, method, args, isVoid, abortSignal) {
+    const id = this._nextId++;
+    this.send({
+      type: "invoke",
+      id,
+      target,
+      method,
+      args: protocol.serializeResult(args),
+      void: isVoid,
+      withAbort: Boolean(abortSignal)
+    });
+    abortSignal?.addEventListener("abort", () => {
+      this.send({
+        type: "abort",
+        id
+      });
+    });
+    if (!isVoid) {
+      const promise = new utils.Deferred();
+      this._pending.set(id, promise);
+      return promise.promise;
+    }
+  }
+  invoke(target, method, args) {
+    return this._invoke(target, method, args, false);
+  }
+  invokeVoid(target, method, args) {
+    this._invoke(target, method, args, true);
+  }
+  invokeWithAbort(target, method, args, abortSignal) {
+    if (abortSignal.aborted) return Promise.reject(abortSignal.reason);
+    return this._invoke(target, method, args, false, abortSignal);
+  }
+  handleResult(msg) {
+    const promise = this._pending.get(msg.id);
+    if (!promise) return;
+    if (msg.error) {
+      promise.reject(errors.deserializeError(msg.error));
+    } else {
+      promise.resolve(protocol.deserializeResult(msg.result));
+    }
+  }
+  makeBinder(target) {
+    return (method, isVoid = false) => {
+      let fn;
+      if (isVoid) {
+        fn = (...args) => this.invokeVoid(target, method, args);
+      } else {
+        fn = (...args) => this.invoke(target, method, args);
+      }
+      return fn;
+    };
+  }
+}
+exports.WorkerInvoker = WorkerInvoker;

package/highlevel/worker/invoker.js

@@ -0,0 +1,66 @@
+import { Deferred } from "@fuman/utils";
+import { deserializeError } from "./errors.js";
+import { serializeResult, deserializeResult } from "./protocol.js";
+class WorkerInvoker {
+  constructor(send) {
+    this.send = send;
+  }
+  _nextId = 0;
+  _pending = /* @__PURE__ */ new Map();
+  _invoke(target, method, args, isVoid, abortSignal) {
+    const id = this._nextId++;
+    this.send({
+      type: "invoke",
+      id,
+      target,
+      method,
+      args: serializeResult(args),
+      void: isVoid,
+      withAbort: Boolean(abortSignal)
+    });
+    abortSignal?.addEventListener("abort", () => {
+      this.send({
+        type: "abort",
+        id
+      });
+    });
+    if (!isVoid) {
+      const promise = new Deferred();
+      this._pending.set(id, promise);
+      return promise.promise;
+    }
+  }
+  invoke(target, method, args) {
+    return this._invoke(target, method, args, false);
+  }
+  invokeVoid(target, method, args) {
+    this._invoke(target, method, args, true);
+  }
+  invokeWithAbort(target, method, args, abortSignal) {
+    if (abortSignal.aborted) return Promise.reject(abortSignal.reason);
+    return this._invoke(target, method, args, false, abortSignal);
+  }
+  handleResult(msg) {
+    const promise = this._pending.get(msg.id);
+    if (!promise) return;
+    if (msg.error) {
+      promise.reject(deserializeError(msg.error));
+    } else {
+      promise.resolve(deserializeResult(msg.result));
+    }
+  }
+  makeBinder(target) {
+    return (method, isVoid = false) => {
+      let fn;
+      if (isVoid) {
+        fn = (...args) => this.invokeVoid(target, method, args);
+      } else {
+        fn = (...args) => this.invoke(target, method, args);
+      }
+      return fn;
+    };
+  }
+}
+export {
+  WorkerInvoker
+};