@mtcute/core 0.17.1 → 0.18.0

package/worker.cjs

@@ -1,589 +1,14 @@
 if (typeof globalThis !== "undefined" && !globalThis._MTCUTE_CJS_DEPRECATION_WARNED) {
   globalThis._MTCUTE_CJS_DEPRECATION_WARNED = true;
-  console.warn("[@mtcute/core] CommonJS support is deprecated and will be removed soon. Please consider switching to ESM, it's " + (/* @__PURE__ */ new Date()).getFullYear() + " already.");
-  console.warn("[@mtcute/core] Learn more about switching to ESM: https://gist.github.com/sindresorhus/a39789f98801d908bbc7ff3ecc99d99c");
+  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 logger = require("./chunks/cjs/D4qcXFYA.js");
-const peersIndex = require("./chunks/cjs/ija5tZ1t.js");
-const controllablePromise = require("./chunks/cjs/CZAB54t2.js");
-const tl = require("@mtcute/tl");
-const platform = require("./chunks/cjs/j7rWn_1y.js");
-const Long = require("long");
-class AppConfigManagerProxy {
-  constructor(invoker) {
-    this.invoker = invoker;
-    const bind = invoker.makeBinder("app-config");
-    this.get = bind("get");
-    this.getField = bind("getField");
-  }
-  get;
-  getField;
-}
-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 === platform.MtTypeAssertionError) {
-    const _error = error;
-    res.name = "MtTypeAssertionError";
-    res.custom = {
-      context: _error.context,
-      expected: _error.expected,
-      actual: _error.actual
-    };
-  } else if (ctor === platform.MtTimeoutError) {
-    const _error = error;
-    res.name = "MtTimeoutError";
-    res.custom = {
-      timeout: _error.timeout
-    };
-  } else if (ctor === controllablePromise.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 === platform.MtArgumentError) {
-    res.name = "MtArgumentError";
-  } else if (ctor === platform.MtSecurityError) {
-    res.name = "MtSecurityError";
-  } else if (ctor === platform.MtUnsupportedError) {
-    res.name = "MtUnsupportedError";
-  } else if (ctor === controllablePromise.MtPeerNotFoundError) {
-    res.name = "MtPeerNotFoundError";
-  } else if (ctor === controllablePromise.MtInvalidPeerTypeError) {
-    res.name = "MtInvalidPeerTypeError";
-  } else if (ctor === controllablePromise.MtEmptyError) {
-    res.name = "MtEmptyError";
-  } else if (ctor instanceof platform.MtcuteError) {
-    res.name = "MtcuteError";
-  }
-  return res;
-}
-function deserializeError(error) {
-  let err2;
-  switch (error.name) {
-    case "MtTypeAssertionError": {
-      const custom = error.custom;
-      err2 = new platform.MtTypeAssertionError(custom.context, custom.expected, custom.actual);
-      break;
-    }
-    case "MtTimeoutError": {
-      const custom = error.custom;
-      err2 = new platform.MtTimeoutError(custom.timeout);
-      break;
-    }
-    case "MtMessageNotFoundError": {
-      const custom = error.custom;
-      err2 = new controllablePromise.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 platform.MtArgumentError();
-      break;
-    case "MtSecurityError":
-      err2 = new platform.MtSecurityError();
-      break;
-    case "MtUnsupportedError":
-      err2 = new platform.MtUnsupportedError();
-      break;
-    case "MtPeerNotFoundError":
-      err2 = new controllablePromise.MtPeerNotFoundError();
-      break;
-    case "MtInvalidPeerTypeError":
-      err2 = new controllablePromise.MtInvalidPeerTypeError("", "");
-      err2.message = error.message;
-      break;
-    case "MtEmptyError":
-      err2 = new controllablePromise.MtEmptyError();
-      break;
-    case "MtcuteError":
-      err2 = new platform.MtcuteError();
-      break;
-    default:
-      err2 = new Error(error.message);
-  }
-  err2.stack = error.stack;
-  return err2;
-}
-function serializeResult(result) {
-  if (ArrayBuffer.isView(result)) return result;
-  if (Array.isArray(result)) {
-    return result.map(serializeResult);
-  }
-  if (result instanceof Map) {
-    for (const [key, value] of result.entries()) {
-      result.set(key, serializeResult(value));
-    }
-    return result;
-  }
-  if (result && typeof result === "object") {
-    const newResult = {};
-    for (const [key, value] of Object.entries(result)) {
-      if (Long.isLong(value)) {
-        newResult[key] = {
-          __type: "long",
-          low: value.low,
-          high: value.high,
-          unsigned: value.unsigned
-        };
-      } else if (typeof value === "object") {
-        newResult[key] = serializeResult(value);
-      } else {
-        newResult[key] = value;
-      }
-    }
-    return newResult;
-  }
-  return result;
-}
-function deserializeResult(result) {
-  if (ArrayBuffer.isView(result)) return result;
-  if (Array.isArray(result)) {
-    return result.map(deserializeResult);
-  }
-  if (result instanceof Map) {
-    for (const [key, value] of result.entries()) {
-      result.set(key, deserializeResult(value));
-    }
-    return result;
-  }
-  if (result && typeof result === "object") {
-    for (const [key, value] of Object.entries(result)) {
-      if (value && typeof value === "object" && value.__type === "long") {
-        result[key] = Long.fromValue(value);
-      } else if (typeof value === "object") {
-        result[key] = deserializeResult(value);
-      }
-    }
-  }
-  return result;
-}
-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 = controllablePromise.createControllablePromise();
-      this._pending.set(id, promise);
-      return 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;
-    };
-  }
-}
-class CurrentUserServiceProxy {
-  _store;
-  _storeFrom;
-  _fetch;
-  _update;
-  constructor(invoker) {
-    const bind = invoker.makeBinder("storage-self");
-    this._store = bind("store");
-    this._storeFrom = bind("storeFrom");
-    this._fetch = bind("fetch");
-    this._update = bind("update");
-  }
-  _cached;
-  async store(info) {
-    await this._store(info);
-    this._cached = info;
-  }
-  async storeFrom(user) {
-    this._cached = await this._storeFrom(user);
-    return this._cached;
-  }
-  async fetch() {
-    if (this._cached) return this._cached;
-    this._cached = await this._fetch();
-    return this._cached;
-  }
-  getCached(safe) {
-    if (this._cached === void 0) {
-      if (safe) return null;
-      throw new platform.MtArgumentError("User info is not cached yet");
-    }
-    return this._cached;
-  }
-  async update(params) {
-    await this._update(params);
-    this._cached = await this._fetch();
-  }
-}
-class PeersServiceProxy {
-  constructor(_invoker) {
-    this._invoker = _invoker;
-    const bind = this._invoker.makeBinder("storage-peers");
-    this.updatePeersFrom = bind("updatePeersFrom");
-    this.store = bind("store");
-    this.getById = bind("getById");
-    this.getByPhone = bind("getByPhone");
-    this.getByUsername = bind("getByUsername");
-    this.getCompleteById = bind("getCompleteById");
-  }
-  updatePeersFrom;
-  store;
-  getById;
-  getByPhone;
-  getByUsername;
-  getCompleteById;
-}
-class TelegramStorageProxy {
-  constructor(_invoker) {
-    this._invoker = _invoker;
-    const bind = this._invoker.makeBinder("storage");
-    this.self = new CurrentUserServiceProxy(this._invoker);
-    this.peers = new PeersServiceProxy(this._invoker);
-    this.clear = bind("clear");
-  }
-  self;
-  peers;
-  clear;
-  // todo - remove once we move these to updates manager
-  updates = null;
-  refMsgs = null;
-}
-class TelegramWorkerPort {
-  constructor(options) {
-    this.options = options;
-    this.log = new logger.LogManager("worker");
-    this._connection = this.connectToWorker(this.options.worker, this._onMessage);
-    this._invoker = new WorkerInvoker(this._connection[0]);
-    this.storage = new TelegramStorageProxy(this._invoker);
-    this.appConfig = new AppConfigManagerProxy(this._invoker);
-    const bind = this._invoker.makeBinder("client");
-    this.prepare = bind("prepare");
-    this._connect = bind("connect");
-    this.close = bind("close");
-    this.notifyLoggedIn = bind("notifyLoggedIn");
-    this.notifyLoggedOut = bind("notifyLoggedOut");
-    this.notifyChannelOpened = bind("notifyChannelOpened");
-    this.notifyChannelClosed = bind("notifyChannelClosed");
-    this.importSession = bind("importSession");
-    this.exportSession = bind("exportSession");
-    this.handleClientUpdate = bind("handleClientUpdate", true);
-    this.getApiCrenetials = bind("getApiCrenetials");
-    this.getPoolSize = bind("getPoolSize");
-    this.getPrimaryDcId = bind("getPrimaryDcId");
-    this.changePrimaryDc = bind("changePrimaryDc");
-    this.computeSrpParams = bind("computeSrpParams");
-    this.computeNewPasswordHash = bind("computeNewPasswordHash");
-    this.startUpdatesLoop = bind("startUpdatesLoop");
-    this.stopUpdatesLoop = bind("stopUpdatesLoop");
-    this.getMtprotoMessageId = bind("getMtprotoMessageId");
-  }
-  log;
-  _connection;
-  _invoker;
-  storage;
-  appConfig;
-  // bound methods
-  prepare;
-  _connect;
-  close;
-  notifyLoggedIn;
-  notifyLoggedOut;
-  notifyChannelOpened;
-  notifyChannelClosed;
-  importSession;
-  exportSession;
-  handleClientUpdate;
-  getApiCrenetials;
-  getPoolSize;
-  getPrimaryDcId;
-  changePrimaryDc;
-  computeSrpParams;
-  computeNewPasswordHash;
-  startUpdatesLoop;
-  stopUpdatesLoop;
-  getMtprotoMessageId;
-  _abortController = new AbortController();
-  stopSignal = this._abortController.signal;
-  call(message, params) {
-    if (params?.abortSignal) {
-      const { abortSignal, ...rest } = params;
-      return this._invoker.invokeWithAbort("client", "call", [message, rest], abortSignal);
-    }
-    return this._invoker.invoke("client", "call", [message, params]);
-  }
-  _serverUpdatesHandler = () => {
-  };
-  onServerUpdate(handler) {
-    this._serverUpdatesHandler = handler;
-  }
-  getServerUpdateHandler() {
-    return this._serverUpdatesHandler;
-  }
-  _errorHandler = () => {
-  };
-  onError(handler) {
-    this._errorHandler = handler;
-  }
-  emitError(err) {
-    this._errorHandler(err);
-  }
-  _updateHandler = () => {
-  };
-  onUpdate(handler) {
-    this._updateHandler = handler;
-  }
-  _connectionStateHandler = () => {
-  };
-  onConnectionState(handler) {
-    this._connectionStateHandler = handler;
-  }
-  _onMessage = (message) => {
-    switch (message.type) {
-      case "log":
-        this.log.handler(message.color, message.level, message.tag, message.fmt, message.args);
-        break;
-      case "server_update":
-        this._serverUpdatesHandler(deserializeResult(message.update));
-        break;
-      case "conn_state":
-        this._connectionStateHandler(message.state);
-        break;
-      case "update": {
-        const peers = new peersIndex.PeersIndex(deserializeResult(message.users), deserializeResult(message.chats));
-        peers.hasMin = message.hasMin;
-        this._updateHandler(deserializeResult(message.update), peers);
-        break;
-      }
-      case "result":
-        this._invoker.handleResult(message);
-        break;
-      case "error":
-        this.emitError(message.error);
-        break;
-      case "stop":
-        this._abortController.abort();
-        break;
-    }
-  };
-  _destroyed = false;
-  destroy(terminate = false) {
-    if (this._destroyed) return;
-    this._connection[1]();
-    this._destroyed = true;
-    if (terminate && "terminate" in this.options.worker) {
-      Promise.resolve(this.options.worker.terminate()).catch(() => {
-      });
-    }
-  }
-  invokeCustom(method, ...args) {
-    return this._invoker.invoke("custom", method, args);
-  }
-  async connect() {
-    await this._connect();
-    await this.storage.self.fetch();
-  }
-}
-class TelegramWorker {
-  constructor(params) {
-    this.params = params;
-    this.broadcast = this.registerWorker((message, respond) => {
-      switch (message.type) {
-        case "invoke":
-          this.onInvoke(message, respond);
-          break;
-        case "abort": {
-          const abort = this.pendingAborts.get(message.id);
-          if (abort) {
-            abort.abort();
-            this.pendingAborts.delete(message.id);
-          }
-        }
-      }
-    });
-    const client = params.client;
-    this.client = client;
-    client.log.mgr.handler = (color, level, tag, fmt, args) => this.broadcast({
-      type: "log",
-      color,
-      level,
-      tag,
-      fmt,
-      args
-    });
-    client.onError(
-      (err) => this.broadcast({
-        type: "error",
-        error: err
-      })
-    );
-    client.onConnectionState(
-      (state) => this.broadcast({
-        type: "conn_state",
-        state
-      })
-    );
-    client.stopSignal.addEventListener("abort", () => this.broadcast({ type: "stop" }));
-    if (client.updates) {
-      client.onUpdate(
-        (update, peers) => this.broadcast({
-          type: "update",
-          update: serializeResult(update),
-          users: serializeResult(peers.users),
-          chats: serializeResult(peers.chats),
-          hasMin: peers.hasMin
-        })
-      );
-    } else {
-      client.onServerUpdate(
-        (update) => this.broadcast({
-          type: "server_update",
-          update: serializeResult(update)
-        })
-      );
-    }
-  }
-  client;
-  broadcast;
-  pendingAborts = /* @__PURE__ */ new Map();
-  onInvoke(msg, respond) {
-    let target;
-    switch (msg.target) {
-      case "custom":
-        target = this.params.customMethods;
-        break;
-      case "client":
-        target = this.client;
-        break;
-      case "storage":
-        target = this.client.storage;
-        break;
-      case "storage-self":
-        target = this.client.storage.self;
-        break;
-      case "storage-peers":
-        target = this.client.storage.peers;
-        break;
-      case "app-config":
-        target = this.client.appConfig;
-        break;
-      default: {
-        respond({
-          type: "result",
-          id: msg.id,
-          error: new Error(`Unknown target ${msg.target}`)
-        });
-        return;
-      }
-    }
-    const method = target[msg.method];
-    if (!method) {
-      respond({
-        type: "result",
-        id: msg.id,
-        error: new Error(`Method ${msg.method} not found on ${msg.target}`)
-      });
-      return;
-    }
-    let args;
-    if (msg.target === "client" && msg.method === "call" && msg.withAbort) {
-      const abort = new AbortController();
-      this.pendingAborts.set(msg.id, abort);
-      args = [
-        deserializeResult(msg.args[0]),
-        {
-          ...msg.args[1],
-          abortSignal: abort.signal
-        }
-      ];
-    } else {
-      args = deserializeResult(msg.args);
-    }
-    Promise.resolve(method.apply(target, args)).then((res) => {
-      if (msg.withAbort) {
-        this.pendingAborts.delete(msg.id);
-      }
-      if (msg.void) return;
-      respond({
-        type: "result",
-        id: msg.id,
-        result: serializeResult(res)
-      });
-    }).catch((err) => {
-      if (msg.withAbort) {
-        this.pendingAborts.delete(msg.id);
-      }
-      respond({
-        type: "result",
-        id: msg.id,
-        error: serializeError(err)
-      });
-    });
-  }
-}
-exports.TelegramWorker = TelegramWorker;
-exports.TelegramWorkerPort = TelegramWorkerPort;
-exports.deserializeResult = deserializeResult;
-exports.serializeResult = serializeResult;
+const port = require("./highlevel/worker/port.cjs");
+const protocol = require("./highlevel/worker/protocol.cjs");
+const worker = require("./highlevel/worker/worker.cjs");
+exports.TelegramWorkerPort = port.TelegramWorkerPort;
+exports.deserializeResult = protocol.deserializeResult;
+exports.serializeResult = protocol.serializeResult;
+exports.TelegramWorker = worker.TelegramWorker;

package/worker.d.cts

@@ -1 +1 @@
-export * from './highlevel/worker/index.js'
+export * from "./highlevel/worker/index.js"

package/worker.d.ts

@@ -1 +1 @@
-export * from './highlevel/worker/index.js'
+export * from "./highlevel/worker/index.js"