@mtcute/node 0.17.0 → 0.18.0

package/utils/tcp.d.cts

@@ -0,0 +1,7 @@
+import { ITcpConnection } from '@fuman/net';
+import { TelegramTransport, IntermediatePacketCodec } from '@mtcute/core';
+import { BasicDcOption } from '@mtcute/core/utils.js';
+export declare class TcpTransport implements TelegramTransport {
+    connect(dc: BasicDcOption): Promise<ITcpConnection>;
+    packetCodec(): IntermediatePacketCodec;
+}

package/utils/tcp.d.ts

@@ -1,29 +1,7 @@
-import { default as EventEmitter } from 'node:events';
-import { Socket } from 'node:net';
-import { IPacketCodec, ITelegramTransport, IntermediatePacketCodec, TransportState } from '@mtcute/core';
-import { BasicDcOption, ICryptoProvider, Logger } from '@mtcute/core/utils.js';
-/**
- * Base for TCP transports.
- * Subclasses must provide packet codec in `_packetCodec` property
- */
-export declare abstract class BaseTcpTransport extends EventEmitter implements ITelegramTransport {
-    protected _currentDc: BasicDcOption | null;
-    protected _state: TransportState;
-    protected _socket: Socket | null;
-    abstract _packetCodec: IPacketCodec;
-    protected _crypto: ICryptoProvider;
-    protected log: Logger;
-    packetCodecInitialized: boolean;
-    private _updateLogPrefix;
-    setup(crypto: ICryptoProvider, log: Logger): void;
-    state(): TransportState;
-    currentDc(): BasicDcOption | null;
-    connect(dc: BasicDcOption, testMode: boolean): void;
-    close(): void;
-    handleError(error: Error): void;
-    handleConnect(): void;
-    send(bytes: Uint8Array): Promise<void>;
-}
-export declare class TcpTransport extends BaseTcpTransport {
-    _packetCodec: IntermediatePacketCodec;
+import { ITcpConnection } from '@fuman/net';
+import { TelegramTransport, IntermediatePacketCodec } from '@mtcute/core';
+import { BasicDcOption } from '@mtcute/core/utils.js';
+export declare class TcpTransport implements TelegramTransport {
+    connect(dc: BasicDcOption): Promise<ITcpConnection>;
+    packetCodec(): IntermediatePacketCodec;
 }

package/utils/tcp.js

@@ -0,0 +1,13 @@
+import { connectTcp } from "@fuman/node";
+import { IntermediatePacketCodec } from "@mtcute/core";
+class TcpTransport {
+  connect(dc) {
+    return connectTcp({ address: dc.ipAddress, port: dc.port });
+  }
+  packetCodec() {
+    return new IntermediatePacketCodec();
+  }
+}
+export {
+  TcpTransport
+};

package/utils.cjs

@@ -1,17 +1,14 @@
 if (typeof globalThis !== "undefined" && !globalThis._MTCUTE_CJS_DEPRECATION_WARNED) {
   globalThis._MTCUTE_CJS_DEPRECATION_WARNED = true;
-  console.warn("[@mtcute/node] CommonJS support is deprecated and will be removed soon. Please consider switching to ESM, it's " + (/* @__PURE__ */ new Date()).getFullYear() + " already.");
-  console.warn("[@mtcute/node] 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 crypto = require("./chunks/cjs/D7i-4e0W.js");
-const streamUtils = require("./chunks/cjs/HP2yqAk_.js");
+const crypto = require("./utils/crypto.cjs");
 const utils_js = require("@mtcute/core/utils.js");
 exports.BaseNodeCryptoProvider = crypto.BaseNodeCryptoProvider;
 exports.NodeCryptoProvider = crypto.NodeCryptoProvider;
-exports.nodeStreamToWeb = streamUtils.nodeStreamToWeb;
-exports.webStreamToNode = streamUtils.webStreamToNode;
 Object.keys(utils_js).forEach((k) => {
   if (k !== "default" && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
     enumerable: true,

package/utils.d.cts

@@ -1,3 +1,2 @@
 export * from './utils/crypto.js';
-export * from './utils/stream-utils.js';
 export * from '@mtcute/core/utils.js';

package/utils.d.ts

@@ -1,3 +1,2 @@
 export * from './utils/crypto.js';
-export * from './utils/stream-utils.js';
 export * from '@mtcute/core/utils.js';

package/utils.js

@@ -1,9 +1,6 @@
-import { BaseNodeCryptoProvider, NodeCryptoProvider } from "./chunks/es/HZgHrOPU.js";
-import { nodeStreamToWeb, webStreamToNode } from "./chunks/es/CKso6cAV.js";
+import { BaseNodeCryptoProvider, NodeCryptoProvider } from "./utils/crypto.js";
 export * from "@mtcute/core/utils.js";
 export {
   BaseNodeCryptoProvider,
-  NodeCryptoProvider,
-  nodeStreamToWeb,
-  webStreamToNode
+  NodeCryptoProvider
 };

package/worker.cjs

@@ -0,0 +1,49 @@
+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 node_worker_threads = require("node:worker_threads");
+const worker_js = require("@mtcute/core/worker.js");
+const platform = require("./utils/platform.cjs");
+let _registered = false;
+class TelegramWorker extends worker_js.TelegramWorker {
+  registerWorker(handler) {
+    if (!node_worker_threads.parentPort) {
+      throw new Error("TelegramWorker must be created from a worker thread");
+    }
+    if (_registered) {
+      throw new Error("TelegramWorker must be created only once");
+    }
+    _registered = true;
+    const port = node_worker_threads.parentPort;
+    const respond = port.postMessage.bind(port);
+    node_worker_threads.parentPort.on("message", (message) => handler(message, respond));
+    return respond;
+  }
+}
+class TelegramWorkerPort extends worker_js.TelegramWorkerPort {
+  constructor(options) {
+    super({
+      worker: options.worker,
+      platform: new platform.NodePlatform()
+    });
+  }
+  connectToWorker(worker, handler) {
+    if (!(worker instanceof node_worker_threads.Worker)) {
+      throw new TypeError("Only worker_threads are supported");
+    }
+    const send = worker.postMessage.bind(worker);
+    worker.on("message", handler);
+    return [
+      send,
+      () => {
+        worker.off("message", handler);
+      }
+    ];
+  }
+}
+exports.TelegramWorker = TelegramWorker;
+exports.TelegramWorkerPort = TelegramWorkerPort;

package/worker.d.cts

@@ -0,0 +1,12 @@
+import { ClientMessageHandler, RespondFn, SendFn, SomeWorker, TelegramWorkerOptions, WorkerCustomMethods, WorkerMessageHandler, TelegramWorker as TelegramWorkerBase, TelegramWorkerPort as TelegramWorkerPortBase } from '@mtcute/core/worker.js';
+export type { TelegramWorkerOptions, WorkerCustomMethods };
+export interface TelegramWorkerPortOptions {
+    worker: SomeWorker;
+}
+export declare class TelegramWorker<T extends WorkerCustomMethods> extends TelegramWorkerBase<T> {
+    registerWorker(handler: WorkerMessageHandler): RespondFn;
+}
+export declare class TelegramWorkerPort<T extends WorkerCustomMethods> extends TelegramWorkerPortBase<T> {
+    constructor(options: TelegramWorkerPortOptions);
+    connectToWorker(worker: SomeWorker, handler: ClientMessageHandler): [SendFn, () => void];
+}

package/worker.d.ts

@@ -1,10 +1,12 @@
-import { ClientMessageHandler, RespondFn, SendFn, SomeWorker, TelegramWorkerOptions, TelegramWorkerPortOptions, WorkerCustomMethods, WorkerMessageHandler, TelegramWorker as TelegramWorkerBase, TelegramWorkerPort as TelegramWorkerPortBase } from '@mtcute/core/worker.js';
-export type { TelegramWorkerOptions, TelegramWorkerPortOptions, WorkerCustomMethods };
+import { ClientMessageHandler, RespondFn, SendFn, SomeWorker, TelegramWorkerOptions, WorkerCustomMethods, WorkerMessageHandler, TelegramWorker as TelegramWorkerBase, TelegramWorkerPort as TelegramWorkerPortBase } from '@mtcute/core/worker.js';
+export type { TelegramWorkerOptions, WorkerCustomMethods };
+export interface TelegramWorkerPortOptions {
+    worker: SomeWorker;
+}
 export declare class TelegramWorker<T extends WorkerCustomMethods> extends TelegramWorkerBase<T> {
     registerWorker(handler: WorkerMessageHandler): RespondFn;
 }
 export declare class TelegramWorkerPort<T extends WorkerCustomMethods> extends TelegramWorkerPortBase<T> {
-    readonly options: TelegramWorkerPortOptions;
     constructor(options: TelegramWorkerPortOptions);
     connectToWorker(worker: SomeWorker, handler: ClientMessageHandler): [SendFn, () => void];
 }

package/worker.js

@@ -0,0 +1,44 @@
+import { parentPort, Worker } from "node:worker_threads";
+import { TelegramWorker as TelegramWorker$1, TelegramWorkerPort as TelegramWorkerPort$1 } from "@mtcute/core/worker.js";
+import { NodePlatform } from "./utils/platform.js";
+let _registered = false;
+class TelegramWorker extends TelegramWorker$1 {
+  registerWorker(handler) {
+    if (!parentPort) {
+      throw new Error("TelegramWorker must be created from a worker thread");
+    }
+    if (_registered) {
+      throw new Error("TelegramWorker must be created only once");
+    }
+    _registered = true;
+    const port = parentPort;
+    const respond = port.postMessage.bind(port);
+    parentPort.on("message", (message) => handler(message, respond));
+    return respond;
+  }
+}
+class TelegramWorkerPort extends TelegramWorkerPort$1 {
+  constructor(options) {
+    super({
+      worker: options.worker,
+      platform: new NodePlatform()
+    });
+  }
+  connectToWorker(worker, handler) {
+    if (!(worker instanceof Worker)) {
+      throw new TypeError("Only worker_threads are supported");
+    }
+    const send = worker.postMessage.bind(worker);
+    worker.on("message", handler);
+    return [
+      send,
+      () => {
+        worker.off("message", handler);
+      }
+    ];
+  }
+}
+export {
+  TelegramWorker,
+  TelegramWorkerPort
+};

package/chunks/cjs/HP2yqAk_.js

@@ -1,79 +0,0 @@
-if (typeof globalThis !== "undefined" && !globalThis._MTCUTE_CJS_DEPRECATION_WARNED) {
-  globalThis._MTCUTE_CJS_DEPRECATION_WARNED = true;
-  console.warn("[@mtcute/node] CommonJS support is deprecated and will be removed soon. Please consider switching to ESM, it's " + (/* @__PURE__ */ new Date()).getFullYear() + " already.");
-  console.warn("[@mtcute/node] Learn more about switching to ESM: https://gist.github.com/sindresorhus/a39789f98801d908bbc7ff3ecc99d99c");
-}
-"use strict";
-const node_stream = require("node:stream");
-const NODE_VERSION = typeof process !== "undefined" && "node" in process.versions ? process.versions.node : null;
-const NODE_VERSION_TUPLE = NODE_VERSION ? /* @__PURE__ */ NODE_VERSION.split(".").map(Number) : null;
-function isNodeVersionAfter(major, minor, patch) {
-  if (!NODE_VERSION_TUPLE) return true;
-  const [a, b, c] = NODE_VERSION_TUPLE;
-  if (a > major) return true;
-  if (a < major) return false;
-  if (b > minor) return true;
-  if (b < minor) return false;
-  return c >= patch;
-}
-function nodeStreamToWeb(stream) {
-  if (typeof node_stream.Readable.toWeb === "function") {
-    return node_stream.Readable.toWeb(stream);
-  }
-  stream.pause();
-  return new ReadableStream({
-    start(c) {
-      stream.on("data", (chunk) => {
-        c.enqueue(chunk);
-      });
-      stream.on("end", () => {
-        c.close();
-      });
-      stream.on("error", (err) => {
-        c.error(err);
-      });
-    },
-    pull() {
-      stream.resume();
-    }
-  });
-}
-function webStreamToNode(stream) {
-  if (typeof node_stream.Readable.fromWeb === "function" && isNodeVersionAfter(18, 13, 0)) {
-    return node_stream.Readable.fromWeb(stream);
-  }
-  const reader = stream.getReader();
-  let ended = false;
-  const readable = new node_stream.Readable({
-    async read() {
-      try {
-        const { done, value } = await reader.read();
-        if (done) {
-          this.push(null);
-        } else {
-          this.push(Buffer.from(value.buffer, value.byteOffset, value.byteLength));
-        }
-      } catch (err) {
-        this.destroy(err);
-      }
-    },
-    destroy(error, cb) {
-      if (!ended) {
-        void reader.cancel(error).catch(() => {
-        }).then(() => {
-          cb(error);
-        });
-        return;
-      }
-      cb(error);
-    }
-  });
-  reader.closed.then(() => {
-    ended = true;
-  }).catch((err) => {
-    readable.destroy(err);
-  });
-  return readable;
-}
-exports.nodeStreamToWeb = nodeStreamToWeb;
-exports.webStreamToNode = webStreamToNode;

package/chunks/cjs/package.json

@@ -1,3 +0,0 @@
-{
-    "type": "commonjs"
-}

package/chunks/es/CKso6cAV.js

@@ -1,75 +0,0 @@
-import { Readable } from "node:stream";
-const NODE_VERSION = typeof process !== "undefined" && "node" in process.versions ? process.versions.node : null;
-const NODE_VERSION_TUPLE = NODE_VERSION ? /* @__PURE__ */ NODE_VERSION.split(".").map(Number) : null;
-function isNodeVersionAfter(major, minor, patch) {
-  if (!NODE_VERSION_TUPLE) return true;
-  const [a, b, c] = NODE_VERSION_TUPLE;
-  if (a > major) return true;
-  if (a < major) return false;
-  if (b > minor) return true;
-  if (b < minor) return false;
-  return c >= patch;
-}
-function nodeStreamToWeb(stream) {
-  if (typeof Readable.toWeb === "function") {
-    return Readable.toWeb(stream);
-  }
-  stream.pause();
-  return new ReadableStream({
-    start(c) {
-      stream.on("data", (chunk) => {
-        c.enqueue(chunk);
-      });
-      stream.on("end", () => {
-        c.close();
-      });
-      stream.on("error", (err) => {
-        c.error(err);
-      });
-    },
-    pull() {
-      stream.resume();
-    }
-  });
-}
-function webStreamToNode(stream) {
-  if (typeof Readable.fromWeb === "function" && isNodeVersionAfter(18, 13, 0)) {
-    return Readable.fromWeb(stream);
-  }
-  const reader = stream.getReader();
-  let ended = false;
-  const readable = new Readable({
-    async read() {
-      try {
-        const { done, value } = await reader.read();
-        if (done) {
-          this.push(null);
-        } else {
-          this.push(Buffer.from(value.buffer, value.byteOffset, value.byteLength));
-        }
-      } catch (err) {
-        this.destroy(err);
-      }
-    },
-    destroy(error, cb) {
-      if (!ended) {
-        void reader.cancel(error).catch(() => {
-        }).then(() => {
-          cb(error);
-        });
-        return;
-      }
-      cb(error);
-    }
-  });
-  reader.closed.then(() => {
-    ended = true;
-  }).catch((err) => {
-    readable.destroy(err);
-  });
-  return readable;
-}
-export {
-  nodeStreamToWeb,
-  webStreamToNode
-};

package/utils/stream-utils.d.ts

@@ -1,3 +0,0 @@
-import { Readable } from 'node:stream';
-export declare function nodeStreamToWeb(stream: Readable): ReadableStream<Uint8Array>;
-export declare function webStreamToNode(stream: ReadableStream<Uint8Array>): Readable;

package/utils/version.d.ts

@@ -1,3 +0,0 @@
-export declare const NODE_VERSION: string | null;
-export declare const NODE_VERSION_TUPLE: number[] | null;
-export declare function isNodeVersionAfter(major: number, minor: number, patch: number): boolean;