@mtcute/core 0.16.7 → 0.16.9

package/worker.js

@@ -1 +1,584 @@
-export * from './esm/highlevel/worker/index.js'
+import { LogManager } from "./chunks/es/BRgz_-S8.js";
+import { PeersIndex } from "./chunks/es/N3PMYmCL.js";
+import { MtMessageNotFoundError, MtPeerNotFoundError, MtInvalidPeerTypeError, MtEmptyError, createControllablePromise } from "./chunks/es/BN3qj7tU.js";
+import { tl } from "@mtcute/tl";
+import { MtTypeAssertionError, MtTimeoutError, MtArgumentError, MtSecurityError, MtUnsupportedError, MtcuteError } from "./chunks/es/DBMBgE7t.js";
+import Long from "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 === 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;
+}
+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 = 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 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 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(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)
+      });
+    });
+  }
+}
+export {
+  TelegramWorker,
+  TelegramWorkerPort,
+  deserializeResult,
+  serializeResult
+};

package/cjs/highlevel/base.d.ts

@@ -1,120 +0,0 @@
-import { tl } from '@mtcute/tl';
-import type Long from 'long';
-import type { MtClientOptions } from '../network/client.js';
-import { MtClient } from '../network/client.js';
-import type { ConnectionKind, RpcCallOptions } from '../network/network-manager.js';
-import type { StorageManagerExtraOptions } from '../storage/storage.js';
-import type { MustEqual } from '../types/utils.js';
-import type { ICryptoProvider, Logger, StringSessionData } from '../utils/index.js';
-import type { ConnectionState, ITelegramClient, ServerUpdateHandler } from './client.types.js';
-import { AppConfigManager } from './managers/app-config-manager.js';
-import type { ITelegramStorageProvider } from './storage/provider.js';
-import type { TelegramStorageManagerExtraOptions } from './storage/storage.js';
-import { TelegramStorageManager } from './storage/storage.js';
-import { UpdatesManager } from './updates/manager.js';
-import type { RawUpdateHandler, UpdatesManagerParams } from './updates/types.js';
-export interface BaseTelegramClientOptions extends MtClientOptions {
-    storage: ITelegramStorageProvider;
-    storageOptions?: StorageManagerExtraOptions & TelegramStorageManagerExtraOptions;
-    updates?: UpdatesManagerParams | false;
-}
-export declare class BaseTelegramClient implements ITelegramClient {
-    readonly params: BaseTelegramClientOptions;
-    readonly updates?: UpdatesManager;
-    private _serverUpdatesHandler;
-    private _connectionStateHandler;
-    readonly log: Logger;
-    readonly mt: MtClient;
-    readonly crypto: ICryptoProvider;
-    readonly storage: TelegramStorageManager;
-    constructor(params: BaseTelegramClientOptions);
-    readonly appConfig: AppConfigManager;
-    private _prepare;
-    /**
-     * **ADVANCED**
-     *
-     * Do all the preparations, but don't connect just yet.
-     * Useful when you want to do some preparations before
-     * connecting, like setting up session.
-     *
-     * Call {@link connect} to actually connect.
-     */
-    prepare(): Promise<void>;
-    private _connected;
-    private _connect;
-    /**
-     * Initialize the connection to the primary DC.
-     *
-     * You shouldn't usually call this method directly as it is called
-     * implicitly the first time you call {@link call}.
-     */
-    connect(): Promise<void>;
-    get isConnected(): boolean;
-    close(): Promise<void>;
-    notifyLoggedIn(auth: tl.auth.TypeAuthorization | tl.RawUser): Promise<tl.RawUser>;
-    notifyLoggedOut(): Promise<void>;
-    notifyChannelOpened(channelId: number, pts?: number): Promise<boolean>;
-    notifyChannelClosed(channelId: number): Promise<boolean>;
-    startUpdatesLoop(): Promise<void>;
-    stopUpdatesLoop(): Promise<void>;
-    /**
-     * Make an RPC call
-     *
-     * This method is still quite low-level and you shouldn't use this
-     * when using high-level API provided by `@mtcute/client`.
-     *
-     * @param message  RPC method to call
-     * @param params  Additional call parameters
-     */
-    call<T extends tl.RpcMethod>(message: MustEqual<T, tl.RpcMethod>, params?: RpcCallOptions): Promise<tl.RpcCallReturn[T['_']]>;
-    /**
-     * Import the session from the given session string.
-     *
-     * Note that the session will only be imported in case
-     * the storage is missing authorization (i.e. does not contain
-     * auth key for the primary DC), otherwise it will be ignored (unless `force`).
-     *
-     * @param session  Session string to import
-     * @param force  Whether to overwrite existing session
-     */
-    importSession(session: string | StringSessionData, force?: boolean): Promise<void>;
-    /**
-     * Export current session to a single *LONG* string, containing
-     * all the needed information.
-     *
-     * > **Warning!** Anyone with this string will be able
-     * > to authorize as you and do anything. Treat this
-     * > as your password, and never give it away!
-     * >
-     * > In case you have accidentally leaked this string,
-     * > make sure to revoke this session in account settings:
-     * > "Privacy & Security" > "Active sessions" >
-     * > find the one containing `mtcute` > Revoke,
-     * > or, in case this is a bot, revoke bot token
-     * > with [@BotFather](//t.me/botfather)
-     */
-    exportSession(): Promise<string>;
-    /**
-     * Register an error handler for the client
-     *
-     * @param handler  Error handler.
-     */
-    onError(handler: (err: unknown) => void): void;
-    emitError(err: unknown): void;
-    handleClientUpdate(updates: tl.TypeUpdates, noDispatch?: boolean): void;
-    onServerUpdate(handler: ServerUpdateHandler): void;
-    getServerUpdateHandler(): ServerUpdateHandler;
-    onUpdate(handler: RawUpdateHandler): void;
-    onConnectionState(handler: (state: ConnectionState) => void): void;
-    getApiCrenetials(): Promise<{
-        id: number;
-        hash: string;
-    }>;
-    getPoolSize(kind: ConnectionKind, dcId?: number): Promise<number>;
-    getPrimaryDcId(): Promise<number>;
-    computeSrpParams(request: tl.account.RawPassword, password: string): Promise<tl.RawInputCheckPasswordSRP>;
-    computeNewPasswordHash(algo: tl.TypePasswordKdfAlgo, password: string): Promise<Uint8Array>;
-    get stopSignal(): AbortSignal;
-    changePrimaryDc(dcId: number): Promise<void>;
-    getMtprotoMessageId(): Promise<Long>;
-}