@mtcute/core 0.6.0 → 0.7.0

package/cjs/highlevel/worker/invoker.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkerInvoker = void 0;
+const controllable_promise_js_1 = require("../../utils/controllable-promise.js");
+const errors_js_1 = require("./errors.js");
+class WorkerInvoker {
+    constructor(send) {
+        this.send = send;
+        this._nextId = 0;
+        this._pending = new Map();
+    }
+    _invoke(target, method, args, isVoid) {
+        const id = this._nextId++;
+        this.send({
+            type: 'invoke',
+            id,
+            target,
+            method,
+            args,
+            void: isVoid,
+        });
+        if (!isVoid) {
+            const promise = (0, controllable_promise_js_1.createControllablePromise)();
+            this._pending.set(id, promise);
+            return promise;
+        }
+    }
+    invoke(target, method, args) {
+        return this._invoke(target, method, args, false);
+    }
+    invokeVoid(target, method, args) {
+        // eslint-disable-next-line @typescript-eslint/no-floating-promises
+        this._invoke(target, method, args, true);
+    }
+    handleResult(msg) {
+        const promise = this._pending.get(msg.id);
+        if (!promise)
+            return;
+        if (msg.error) {
+            promise.reject((0, errors_js_1.deserializeError)(msg.error));
+        }
+        else {
+            promise.resolve(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;
+//# sourceMappingURL=invoker.js.map

package/cjs/highlevel/worker/invoker.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"invoker.js","sourceRoot":"","sources":["../../../../src/highlevel/worker/invoker.ts"],"names":[],"mappings":";;;AAAA,iFAAoG;AACpG,2CAA8C;AAK9C,MAAa,aAAa;IACtB,YAAoB,IAAY;QAAZ,SAAI,GAAJ,IAAI,CAAQ;QAExB,YAAO,GAAG,CAAC,CAAA;QACX,aAAQ,GAAG,IAAI,GAAG,EAA+B,CAAA;IAHtB,CAAC;IAK5B,OAAO,CAAC,MAAoB,EAAE,MAAc,EAAE,IAAe,EAAE,MAAe;QAClF,MAAM,EAAE,GAAG,IAAI,CAAC,OAAO,EAAE,CAAA;QAEzB,IAAI,CAAC,IAAI,CAAC;YACN,IAAI,EAAE,QAAQ;YACd,EAAE;YACF,MAAM;YACN,MAAM;YACN,IAAI;YACJ,IAAI,EAAE,MAAM;SACf,CAAC,CAAA;QAEF,IAAI,CAAC,MAAM,EAAE;YACT,MAAM,OAAO,GAAG,IAAA,mDAAyB,GAAE,CAAA;YAE3C,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,EAAE,EAAE,OAAO,CAAC,CAAA;YAE9B,OAAO,OAAO,CAAA;SACjB;IACL,CAAC;IAED,MAAM,CAAC,MAAoB,EAAE,MAAc,EAAE,IAAe;QACxD,OAAO,IAAI,CAAC,OAAO,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,KAAK,CAAqB,CAAA;IACxE,CAAC;IAED,UAAU,CAAC,MAAoB,EAAE,MAAc,EAAE,IAAe;QAC5D,mEAAmE;QACnE,IAAI,CAAC,OAAO,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,IAAI,CAAC,CAAA;IAC5C,CAAC;IAED,YAAY,CAAC,GAAuD;QAChE,MAAM,OAAO,GAAG,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC,CAAA;QACzC,IAAI,CAAC,OAAO;YAAE,OAAM;QAEpB,IAAI,GAAG,CAAC,KAAK,EAAE;YACX,OAAO,CAAC,MAAM,CAAC,IAAA,4BAAgB,EAAC,GAAG,CAAC,KAAK,CAAC,CAAC,CAAA;SAC9C;aAAM;YACH,OAAO,CAAC,OAAO,CAAC,GAAG,CAAC,MAAM,CAAC,CAAA;SAC9B;IACL,CAAC;IAED,UAAU,CAAI,MAAoB;QAC9B,OAAO,CAAoB,MAAS,EAAE,MAAM,GAAG,KAAK,EAAE,EAAE;YACpD,IAAI,EAAE,CAAA;YAEN,IAAI,MAAM,EAAE;gBACR,EAAE,GAAG,CAAC,GAAG,IAAe,EAAE,EAAE,CAAC,IAAI,CAAC,UAAU,CAAC,MAAM,EAAE,MAAgB,EAAE,IAAI,CAAC,CAAA;aAC/E;iBAAM;gBACH,EAAE,GAAG,CAAC,GAAG,IAAe,EAAE,EAAE,CAAC,IAAI,CAAC,MAAM,CAAC,MAAM,EAAE,MAAgB,EAAE,IAAI,CAAC,CAAA;aAC3E;YAED,OAAO,EAAU,CAAA;QACrB,CAAC,CAAA;IACL,CAAC;CACJ;AA5DD,sCA4DC","sourcesContent":["import { ControllablePromise, createControllablePromise } from '../../utils/controllable-promise.js'\nimport { deserializeError } from './errors.js'\nimport { SendFn, WorkerInboundMessage, WorkerOutboundMessage } from './protocol.js'\n\nexport type InvokeTarget = Extract<WorkerInboundMessage, { type: 'invoke' }>['target']\n\nexport class WorkerInvoker {\n    constructor(private send: SendFn) {}\n\n    private _nextId = 0\n    private _pending = new Map<number, ControllablePromise>()\n\n    private _invoke(target: InvokeTarget, method: string, args: unknown[], isVoid: boolean) {\n        const id = this._nextId++\n\n        this.send({\n            type: 'invoke',\n            id,\n            target,\n            method,\n            args,\n            void: isVoid,\n        })\n\n        if (!isVoid) {\n            const promise = createControllablePromise()\n\n            this._pending.set(id, promise)\n\n            return promise\n        }\n    }\n\n    invoke(target: InvokeTarget, method: string, args: unknown[]): Promise<unknown> {\n        return this._invoke(target, method, args, false) as Promise<unknown>\n    }\n\n    invokeVoid(target: InvokeTarget, method: string, args: unknown[]): void {\n        // eslint-disable-next-line @typescript-eslint/no-floating-promises\n        this._invoke(target, method, args, true)\n    }\n\n    handleResult(msg: Extract<WorkerOutboundMessage, { type: 'result' }>) {\n        const promise = this._pending.get(msg.id)\n        if (!promise) return\n\n        if (msg.error) {\n            promise.reject(deserializeError(msg.error))\n        } else {\n            promise.resolve(msg.result)\n        }\n    }\n\n    makeBinder<T>(target: InvokeTarget) {\n        return <K extends keyof T>(method: K, isVoid = false) => {\n            let fn\n\n            if (isVoid) {\n                fn = (...args: unknown[]) => this.invokeVoid(target, method as string, args)\n            } else {\n                fn = (...args: unknown[]) => this.invoke(target, method as string, args)\n            }\n\n            return fn as T[K]\n        }\n    }\n}\n"]}

package/cjs/highlevel/worker/platform/connect.d.ts

@@ -0,0 +1,2 @@
+import { ClientMessageHandler, SendFn, SomeWorker } from '../protocol.js';
+export declare function connectToWorker(worker: SomeWorker, handler: ClientMessageHandler): [SendFn, () => void];

package/cjs/highlevel/worker/platform/connect.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.connectToWorker = void 0;
+const worker_threads_1 = require("worker_threads");
+function connectToWorker(worker, handler) {
+    if (!(worker instanceof worker_threads_1.Worker)) {
+        throw new Error('Only worker_threads are supported');
+    }
+    const send = worker.postMessage.bind(worker);
+    worker.on('message', handler);
+    return [
+        send,
+        () => {
+            worker.off('message', handler);
+        },
+    ];
+}
+exports.connectToWorker = connectToWorker;
+//# sourceMappingURL=connect.js.map

package/cjs/highlevel/worker/platform/connect.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"connect.js","sourceRoot":"","sources":["../../../../../src/highlevel/worker/platform/connect.ts"],"names":[],"mappings":";;;AAAA,mDAAuC;AAIvC,SAAgB,eAAe,CAAC,MAAkB,EAAE,OAA6B;IAC7E,IAAI,CAAC,CAAC,MAAM,YAAY,uBAAM,CAAC,EAAE;QAC7B,MAAM,IAAI,KAAK,CAAC,mCAAmC,CAAC,CAAA;KACvD;IAED,MAAM,IAAI,GAAW,MAAM,CAAC,WAAW,CAAC,IAAI,CAAC,MAAM,CAAC,CAAA;IAEpD,MAAM,CAAC,EAAE,CAAC,SAAS,EAAE,OAAO,CAAC,CAAA;IAE7B,OAAO;QACH,IAAI;QACJ,GAAG,EAAE;YACD,MAAM,CAAC,GAAG,CAAC,SAAS,EAAE,OAAO,CAAC,CAAA;QAClC,CAAC;KACJ,CAAA;AACL,CAAC;AAfD,0CAeC","sourcesContent":["import { Worker } from 'worker_threads'\n\nimport { ClientMessageHandler, SendFn, SomeWorker } from '../protocol.js'\n\nexport function connectToWorker(worker: SomeWorker, handler: ClientMessageHandler): [SendFn, () => void] {\n    if (!(worker instanceof Worker)) {\n        throw new Error('Only worker_threads are supported')\n    }\n\n    const send: SendFn = worker.postMessage.bind(worker)\n\n    worker.on('message', handler)\n\n    return [\n        send,\n        () => {\n            worker.off('message', handler)\n        },\n    ]\n}\n"]}

package/cjs/highlevel/worker/platform/connect.web.d.ts

@@ -0,0 +1,2 @@
+import { ClientMessageHandler, SendFn, SomeWorker } from '../protocol.js';
+export declare function connectToWorker(worker: SomeWorker, handler: ClientMessageHandler): [SendFn, () => void];

package/cjs/highlevel/worker/platform/connect.web.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.connectToWorker = void 0;
+const exit_hook_js_1 = require("../../../utils/platform/exit-hook.js");
+function connectToWorker(worker, handler) {
+    if (worker instanceof Worker) {
+        const send = worker.postMessage.bind(worker);
+        const messageHandler = (ev) => {
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+            handler(ev.data);
+        };
+        worker.addEventListener('message', messageHandler);
+        return [
+            send,
+            () => {
+                worker.removeEventListener('message', messageHandler);
+            },
+        ];
+    }
+    if (worker instanceof SharedWorker) {
+        const send = worker.port.postMessage.bind(worker.port);
+        const pingInterval = setInterval(() => {
+            worker.port.postMessage({ __type__: 'ping' });
+        }, 10000);
+        const messageHandler = (ev) => {
+            if (ev.data.__type__ === 'timeout') {
+                // we got disconnected from the worker due to timeout
+                // if the page is still alive (which is unlikely), we should reconnect
+                // however it's not really possible with SharedWorker API without re-creating the worker
+                // so we just reload the page for now
+                location.reload();
+                return;
+            }
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+            handler(ev.data);
+        };
+        worker.port.addEventListener('message', messageHandler);
+        worker.port.start();
+        const close = () => {
+            clearInterval(pingInterval);
+            worker.port.postMessage({ __type__: 'close' });
+            worker.port.removeEventListener('message', messageHandler);
+            worker.port.close();
+        };
+        (0, exit_hook_js_1.beforeExit)(close);
+        return [send, close];
+    }
+    throw new Error('Only workers and shared workers are supported');
+}
+exports.connectToWorker = connectToWorker;
+//# sourceMappingURL=connect.web.js.map

package/cjs/highlevel/worker/platform/connect.web.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"connect.web.js","sourceRoot":"","sources":["../../../../../src/highlevel/worker/platform/connect.web.ts"],"names":[],"mappings":";;;AAAA,uEAAiE;AAGjE,SAAgB,eAAe,CAAC,MAAkB,EAAE,OAA6B;IAC7E,IAAI,MAAM,YAAY,MAAM,EAAE;QAC1B,MAAM,IAAI,GAAW,MAAM,CAAC,WAAW,CAAC,IAAI,CAAC,MAAM,CAAC,CAAA;QAEpD,MAAM,cAAc,GAAG,CAAC,EAAgB,EAAE,EAAE;YACxC,iEAAiE;YACjE,OAAO,CAAC,EAAE,CAAC,IAAI,CAAC,CAAA;QACpB,CAAC,CAAA;QAED,MAAM,CAAC,gBAAgB,CAAC,SAAS,EAAE,cAAc,CAAC,CAAA;QAElD,OAAO;YACH,IAAI;YACJ,GAAG,EAAE;gBACD,MAAM,CAAC,mBAAmB,CAAC,SAAS,EAAE,cAAc,CAAC,CAAA;YACzD,CAAC;SACJ,CAAA;KACJ;IAED,IAAI,MAAM,YAAY,YAAY,EAAE;QAChC,MAAM,IAAI,GAAW,MAAM,CAAC,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,CAAA;QAE9D,MAAM,YAAY,GAAG,WAAW,CAAC,GAAG,EAAE;YAClC,MAAM,CAAC,IAAI,CAAC,WAAW,CAAC,EAAE,QAAQ,EAAE,MAAM,EAAE,CAAC,CAAA;QACjD,CAAC,EAAE,KAAK,CAAC,CAAA;QAET,MAAM,cAAc,GAAG,CAAC,EAAgB,EAAE,EAAE;YACxC,IAAI,EAAE,CAAC,IAAI,CAAC,QAAQ,KAAK,SAAS,EAAE;gBAChC,qDAAqD;gBACrD,sEAAsE;gBACtE,wFAAwF;gBACxF,qCAAqC;gBACrC,QAAQ,CAAC,MAAM,EAAE,CAAA;gBAEjB,OAAM;aACT;YAED,iEAAiE;YACjE,OAAO,CAAC,EAAE,CAAC,IAAI,CAAC,CAAA;QACpB,CAAC,CAAA;QAED,MAAM,CAAC,IAAI,CAAC,gBAAgB,CAAC,SAAS,EAAE,cAAc,CAAC,CAAA;QACvD,MAAM,CAAC,IAAI,CAAC,KAAK,EAAE,CAAA;QAEnB,MAAM,KAAK,GAAG,GAAG,EAAE;YACf,aAAa,CAAC,YAAY,CAAC,CAAA;YAC3B,MAAM,CAAC,IAAI,CAAC,WAAW,CAAC,EAAE,QAAQ,EAAE,OAAO,EAAE,CAAC,CAAA;YAC9C,MAAM,CAAC,IAAI,CAAC,mBAAmB,CAAC,SAAS,EAAE,cAAc,CAAC,CAAA;YAC1D,MAAM,CAAC,IAAI,CAAC,KAAK,EAAE,CAAA;QACvB,CAAC,CAAA;QAED,IAAA,yBAAU,EAAC,KAAK,CAAC,CAAA;QAEjB,OAAO,CAAC,IAAI,EAAE,KAAK,CAAC,CAAA;KACvB;IAED,MAAM,IAAI,KAAK,CAAC,+CAA+C,CAAC,CAAA;AACpE,CAAC;AAzDD,0CAyDC","sourcesContent":["import { beforeExit } from '../../../utils/platform/exit-hook.js'\nimport { ClientMessageHandler, SendFn, SomeWorker } from '../protocol.js'\n\nexport function connectToWorker(worker: SomeWorker, handler: ClientMessageHandler): [SendFn, () => void] {\n    if (worker instanceof Worker) {\n        const send: SendFn = worker.postMessage.bind(worker)\n\n        const messageHandler = (ev: MessageEvent) => {\n            // eslint-disable-next-line @typescript-eslint/no-unsafe-argument\n            handler(ev.data)\n        }\n\n        worker.addEventListener('message', messageHandler)\n\n        return [\n            send,\n            () => {\n                worker.removeEventListener('message', messageHandler)\n            },\n        ]\n    }\n\n    if (worker instanceof SharedWorker) {\n        const send: SendFn = worker.port.postMessage.bind(worker.port)\n\n        const pingInterval = setInterval(() => {\n            worker.port.postMessage({ __type__: 'ping' })\n        }, 10000)\n\n        const messageHandler = (ev: MessageEvent) => {\n            if (ev.data.__type__ === 'timeout') {\n                // we got disconnected from the worker due to timeout\n                // if the page is still alive (which is unlikely), we should reconnect\n                // however it's not really possible with SharedWorker API without re-creating the worker\n                // so we just reload the page for now\n                location.reload()\n\n                return\n            }\n\n            // eslint-disable-next-line @typescript-eslint/no-unsafe-argument\n            handler(ev.data)\n        }\n\n        worker.port.addEventListener('message', messageHandler)\n        worker.port.start()\n\n        const close = () => {\n            clearInterval(pingInterval)\n            worker.port.postMessage({ __type__: 'close' })\n            worker.port.removeEventListener('message', messageHandler)\n            worker.port.close()\n        }\n\n        beforeExit(close)\n\n        return [send, close]\n    }\n\n    throw new Error('Only workers and shared workers are supported')\n}\n"]}

package/cjs/highlevel/worker/platform/register.d.ts

@@ -0,0 +1,2 @@
+import { RespondFn, WorkerMessageHandler } from '../protocol.js';
+export declare function registerWorker(handler: WorkerMessageHandler): RespondFn;

package/cjs/highlevel/worker/platform/register.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerWorker = void 0;
+const worker_threads_1 = require("worker_threads");
+const registered = false;
+function registerWorker(handler) {
+    if (!worker_threads_1.parentPort) {
+        throw new Error('registerWorker() must be called from a worker thread');
+    }
+    if (registered) {
+        throw new Error('registerWorker() must be called only once');
+    }
+    const port = worker_threads_1.parentPort;
+    const respond = port.postMessage.bind(port);
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+    worker_threads_1.parentPort.on('message', (message) => handler(message, respond));
+    return respond;
+}
+exports.registerWorker = registerWorker;
+//# sourceMappingURL=register.js.map

package/cjs/highlevel/worker/platform/register.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"register.js","sourceRoot":"","sources":["../../../../../src/highlevel/worker/platform/register.ts"],"names":[],"mappings":";;;AAAA,mDAA2C;AAI3C,MAAM,UAAU,GAAG,KAAK,CAAA;AAExB,SAAgB,cAAc,CAAC,OAA6B;IACxD,IAAI,CAAC,2BAAU,EAAE;QACb,MAAM,IAAI,KAAK,CAAC,sDAAsD,CAAC,CAAA;KAC1E;IACD,IAAI,UAAU,EAAE;QACZ,MAAM,IAAI,KAAK,CAAC,2CAA2C,CAAC,CAAA;KAC/D;IAED,MAAM,IAAI,GAAG,2BAAU,CAAA;IAEvB,MAAM,OAAO,GAAc,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,IAAI,CAAC,CAAA;IAEtD,iEAAiE;IACjE,2BAAU,CAAC,EAAE,CAAC,SAAS,EAAE,CAAC,OAAO,EAAE,EAAE,CAAC,OAAO,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC,CAAA;IAEhE,OAAO,OAAO,CAAA;AAClB,CAAC;AAhBD,wCAgBC","sourcesContent":["import { parentPort } from 'worker_threads'\n\nimport { RespondFn, WorkerMessageHandler } from '../protocol.js'\n\nconst registered = false\n\nexport function registerWorker(handler: WorkerMessageHandler): RespondFn {\n    if (!parentPort) {\n        throw new Error('registerWorker() must be called from a worker thread')\n    }\n    if (registered) {\n        throw new Error('registerWorker() must be called only once')\n    }\n\n    const port = parentPort\n\n    const respond: RespondFn = port.postMessage.bind(port)\n\n    // eslint-disable-next-line @typescript-eslint/no-unsafe-argument\n    parentPort.on('message', (message) => handler(message, respond))\n\n    return respond\n}\n"]}

package/cjs/highlevel/worker/platform/register.web.d.ts

@@ -0,0 +1,2 @@
+import { RespondFn, WorkerMessageHandler } from '../protocol.js';
+export declare function registerWorker(handler: WorkerMessageHandler): RespondFn;

package/cjs/highlevel/worker/platform/register.web.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerWorker = void 0;
+const registered = false;
+function registerWorker(handler) {
+    if (registered) {
+        throw new Error('registerWorker() must be called only once');
+    }
+    if (typeof WorkerGlobalScope !== 'undefined' && self instanceof WorkerGlobalScope) {
+        const respond = self.postMessage.bind(self);
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+        self.addEventListener('message', (message) => handler(message.data, respond));
+        return respond;
+    }
+    if (typeof SharedWorkerGlobalScope !== 'undefined' && self instanceof SharedWorkerGlobalScope) {
+        const connections = [];
+        const broadcast = (message) => {
+            for (const port of connections) {
+                port.postMessage(message);
+            }
+        };
+        self.onconnect = (event) => {
+            const port = event.ports[0];
+            connections.push(port);
+            const respond = port.postMessage.bind(port);
+            // not very reliable, but better than nothing
+            // SharedWorker API doesn't provide a way to detect when the client closes the connection
+            // so we just assume that the client is done when it sends a 'close' message
+            // and keep a timeout for the case when the client closes without sending a 'close' message
+            const onClose = () => {
+                port.close();
+                const idx = connections.indexOf(port);
+                if (idx >= 0) {
+                    connections.splice(connections.indexOf(port), 1);
+                }
+            };
+            const onTimeout = () => {
+                console.warn('some connection timed out!');
+                respond({ __type__: 'timeout' });
+                onClose();
+            };
+            // 60s should be a reasonable timeout considering that the client should send a ping every 10s
+            // so even if the browser has suspended the timers, we should still get a ping within a minute
+            let timeout = setTimeout(onTimeout, 60000);
+            port.addEventListener('message', (message) => {
+                if (message.data.__type__ === 'close') {
+                    onClose();
+                    return;
+                }
+                if (message.data.__type__ === 'ping') {
+                    clearTimeout(timeout);
+                    timeout = setTimeout(onTimeout, 60000);
+                    return;
+                }
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+                handler(message.data, respond);
+            });
+        };
+        return broadcast;
+    }
+    throw new Error('registerWorker() must be called from a worker');
+}
+exports.registerWorker = registerWorker;
+//# sourceMappingURL=register.web.js.map

package/cjs/highlevel/worker/platform/register.web.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"register.web.js","sourceRoot":"","sources":["../../../../../src/highlevel/worker/platform/register.web.ts"],"names":[],"mappings":";;;AAEA,MAAM,UAAU,GAAG,KAAK,CAAA;AAExB,SAAgB,cAAc,CAAC,OAA6B;IACxD,IAAI,UAAU,EAAE;QACZ,MAAM,IAAI,KAAK,CAAC,2CAA2C,CAAC,CAAA;KAC/D;IAED,IAAI,OAAO,iBAAiB,KAAK,WAAW,IAAI,IAAI,YAAY,iBAAiB,EAAE;QAC/E,MAAM,OAAO,GAAc,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,IAAI,CAAC,CAAA;QAEtD,iEAAiE;QACjE,IAAI,CAAC,gBAAgB,CAAC,SAAS,EAAE,CAAC,OAAO,EAAE,EAAE,CAAC,OAAO,CAAC,OAAO,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC,CAAA;QAE7E,OAAO,OAAO,CAAA;KACjB;IAED,IAAI,OAAO,uBAAuB,KAAK,WAAW,IAAI,IAAI,YAAY,uBAAuB,EAAE;QAC3F,MAAM,WAAW,GAAkB,EAAE,CAAA;QAErC,MAAM,SAAS,GAAG,CAAC,OAAgB,EAAE,EAAE;YACnC,KAAK,MAAM,IAAI,IAAI,WAAW,EAAE;gBAC5B,IAAI,CAAC,WAAW,CAAC,OAAO,CAAC,CAAA;aAC5B;QACL,CAAC,CAAA;QAED,IAAI,CAAC,SAAS,GAAG,CAAC,KAAK,EAAE,EAAE;YACvB,MAAM,IAAI,GAAG,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,CAAA;YAC3B,WAAW,CAAC,IAAI,CAAC,IAAI,CAAC,CAAA;YAEtB,MAAM,OAAO,GAAG,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,IAAI,CAAC,CAAA;YAE3C,6CAA6C;YAC7C,yFAAyF;YACzF,4EAA4E;YAC5E,2FAA2F;YAC3F,MAAM,OAAO,GAAG,GAAG,EAAE;gBACjB,IAAI,CAAC,KAAK,EAAE,CAAA;gBACZ,MAAM,GAAG,GAAG,WAAW,CAAC,OAAO,CAAC,IAAI,CAAC,CAAA;gBAErC,IAAI,GAAG,IAAI,CAAC,EAAE;oBACV,WAAW,CAAC,MAAM,CAAC,WAAW,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC,CAAA;iBACnD;YACL,CAAC,CAAA;YAED,MAAM,SAAS,GAAG,GAAG,EAAE;gBACnB,OAAO,CAAC,IAAI,CAAC,4BAA4B,CAAC,CAAA;gBAC1C,OAAO,CAAC,EAAE,QAAQ,EAAE,SAAS,EAAE,CAAC,CAAA;gBAChC,OAAO,EAAE,CAAA;YACb,CAAC,CAAA;YAED,8FAA8F;YAC9F,8FAA8F;YAC9F,IAAI,OAAO,GAAG,UAAU,CAAC,SAAS,EAAE,KAAK,CAAC,CAAA;YAE1C,IAAI,CAAC,gBAAgB,CAAC,SAAS,EAAE,CAAC,OAAO,EAAE,EAAE;gBACzC,IAAI,OAAO,CAAC,IAAI,CAAC,QAAQ,KAAK,OAAO,EAAE;oBACnC,OAAO,EAAE,CAAA;oBAET,OAAM;iBACT;gBAED,IAAI,OAAO,CAAC,IAAI,CAAC,QAAQ,KAAK,MAAM,EAAE;oBAClC,YAAY,CAAC,OAAO,CAAC,CAAA;oBACrB,OAAO,GAAG,UAAU,CAAC,SAAS,EAAE,KAAK,CAAC,CAAA;oBAEtC,OAAM;iBACT;gBAED,iEAAiE;gBACjE,OAAO,CAAC,OAAO,CAAC,IAAI,EAAE,OAAO,CAAC,CAAA;YAClC,CAAC,CAAC,CAAA;QACN,CAAC,CAAA;QAED,OAAO,SAAS,CAAA;KACnB;IAED,MAAM,IAAI,KAAK,CAAC,+CAA+C,CAAC,CAAA;AACpE,CAAC;AA3ED,wCA2EC","sourcesContent":["import { RespondFn, WorkerMessageHandler } from '../protocol.js'\n\nconst registered = false\n\nexport function registerWorker(handler: WorkerMessageHandler): RespondFn {\n    if (registered) {\n        throw new Error('registerWorker() must be called only once')\n    }\n\n    if (typeof WorkerGlobalScope !== 'undefined' && self instanceof WorkerGlobalScope) {\n        const respond: RespondFn = self.postMessage.bind(self)\n\n        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument\n        self.addEventListener('message', (message) => handler(message.data, respond))\n\n        return respond\n    }\n\n    if (typeof SharedWorkerGlobalScope !== 'undefined' && self instanceof SharedWorkerGlobalScope) {\n        const connections: MessagePort[] = []\n\n        const broadcast = (message: unknown) => {\n            for (const port of connections) {\n                port.postMessage(message)\n            }\n        }\n\n        self.onconnect = (event) => {\n            const port = event.ports[0]\n            connections.push(port)\n\n            const respond = port.postMessage.bind(port)\n\n            // not very reliable, but better than nothing\n            // SharedWorker API doesn't provide a way to detect when the client closes the connection\n            // so we just assume that the client is done when it sends a 'close' message\n            // and keep a timeout for the case when the client closes without sending a 'close' message\n            const onClose = () => {\n                port.close()\n                const idx = connections.indexOf(port)\n\n                if (idx >= 0) {\n                    connections.splice(connections.indexOf(port), 1)\n                }\n            }\n\n            const onTimeout = () => {\n                console.warn('some connection timed out!')\n                respond({ __type__: 'timeout' })\n                onClose()\n            }\n\n            // 60s should be a reasonable timeout considering that the client should send a ping every 10s\n            // so even if the browser has suspended the timers, we should still get a ping within a minute\n            let timeout = setTimeout(onTimeout, 60000)\n\n            port.addEventListener('message', (message) => {\n                if (message.data.__type__ === 'close') {\n                    onClose()\n\n                    return\n                }\n\n                if (message.data.__type__ === 'ping') {\n                    clearTimeout(timeout)\n                    timeout = setTimeout(onTimeout, 60000)\n\n                    return\n                }\n\n                // eslint-disable-next-line @typescript-eslint/no-unsafe-argument\n                handler(message.data, respond)\n            })\n        }\n\n        return broadcast\n    }\n\n    throw new Error('registerWorker() must be called from a worker')\n}\n"]}

package/cjs/highlevel/worker/port.d.ts

@@ -0,0 +1,53 @@
+import { tl } from '@mtcute/tl';
+import { LogManager } from '../../utils/logger.js';
+import { ITelegramClient } from '../client.types.js';
+import { RawUpdateHandler } from '../updates/types.js';
+import { AppConfigManagerProxy } from './app-config.js';
+import { SomeWorker, WorkerCustomMethods } from './protocol.js';
+import { TelegramStorageProxy } from './storage.js';
+export interface TelegramWorkerPortOptions {
+    worker: SomeWorker;
+}
+export declare class TelegramWorkerPort<Custom extends WorkerCustomMethods> implements ITelegramClient {
+    readonly options: TelegramWorkerPortOptions;
+    constructor(options: TelegramWorkerPortOptions);
+    readonly log: LogManager;
+    private _serverUpdatesHandler;
+    onServerUpdate(handler: (updates: tl.TypeUpdates) => void): void;
+    private _errorHandler;
+    onError(handler: (err: unknown) => void): void;
+    emitError(err: unknown): void;
+    private _updateHandler;
+    onUpdate(handler: RawUpdateHandler): void;
+    private _onMessage;
+    private _connection;
+    private _invoker;
+    private _bind;
+    readonly storage: TelegramStorageProxy;
+    readonly appConfig: AppConfigManagerProxy;
+    private _destroyed;
+    destroy(terminate?: boolean): void;
+    invokeCustom<T extends keyof Custom>(method: T, ...args: Parameters<Custom[T]>): Promise<ReturnType<Custom[T]>>;
+    readonly prepare: () => Promise<void>;
+    private _connect;
+    connect(): Promise<void>;
+    readonly close: () => Promise<void>;
+    readonly notifyLoggedIn: (auth: tl.RawUser | tl.auth.TypeAuthorization) => Promise<tl.RawUser>;
+    readonly notifyLoggedOut: () => Promise<void>;
+    readonly notifyChannelOpened: (channelId: number, pts?: number | undefined) => Promise<boolean>;
+    readonly notifyChannelClosed: (channelId: number) => Promise<boolean>;
+    readonly call: <T extends tl.RpcMethod>(message: import("../../index.js").MustEqual<T, tl.RpcMethod>, params?: import("../../index.js").RpcCallOptions | undefined) => Promise<tl.RpcCallReturn[T["_"]]>;
+    readonly importSession: (session: string | import("../../utils/string-session.js").StringSessionData, force?: boolean | undefined) => Promise<void>;
+    readonly exportSession: () => Promise<string>;
+    readonly handleClientUpdate: (updates: tl.TypeUpdates, noDispatch?: boolean | undefined) => void;
+    readonly getApiCrenetials: () => Promise<{
+        id: number;
+        hash: string;
+    }>;
+    readonly getPoolSize: (kind: import("../../index.js").ConnectionKind, dcId?: number | undefined) => Promise<number>;
+    readonly getPrimaryDcId: () => Promise<number>;
+    readonly computeSrpParams: (request: tl.account.RawPassword, password: string) => Promise<tl.RawInputCheckPasswordSRP>;
+    readonly computeNewPasswordHash: (algo: tl.TypePasswordKdfAlgo, password: string) => Promise<Uint8Array>;
+    readonly startUpdatesLoop: () => Promise<void>;
+    readonly stopUpdatesLoop: () => Promise<void>;
+}

package/cjs/highlevel/worker/port.js

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TelegramWorkerPort = void 0;
+const logger_js_1 = require("../../utils/logger.js");
+const peers_index_js_1 = require("../types/peers/peers-index.js");
+const app_config_js_1 = require("./app-config.js");
+const invoker_js_1 = require("./invoker.js");
+const connect_js_1 = require("./platform/connect.js");
+const storage_js_1 = require("./storage.js");
+class TelegramWorkerPort {
+    constructor(options) {
+        this.options = options;
+        this.log = new logger_js_1.LogManager('worker');
+        this._serverUpdatesHandler = () => { };
+        this._errorHandler = () => { };
+        this._updateHandler = () => { };
+        this._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(message.update);
+                    break;
+                case 'update': {
+                    const peers = new peers_index_js_1.PeersIndex(message.users, message.chats);
+                    peers.hasMin = message.hasMin;
+                    this._updateHandler(message.update, peers);
+                    break;
+                }
+                case 'result':
+                    this._invoker.handleResult(message);
+                    break;
+                case 'error':
+                    this.emitError(message.error);
+                    break;
+            }
+        };
+        this._connection = (0, connect_js_1.connectToWorker)(this.options.worker, this._onMessage);
+        this._invoker = new invoker_js_1.WorkerInvoker(this._connection[0]);
+        this._bind = this._invoker.makeBinder('client');
+        this.storage = new storage_js_1.TelegramStorageProxy(this._invoker);
+        this.appConfig = new app_config_js_1.AppConfigManagerProxy(this._invoker);
+        this._destroyed = false;
+        this.prepare = this._bind('prepare');
+        this._connect = this._bind('connect');
+        this.close = this._bind('close');
+        this.notifyLoggedIn = this._bind('notifyLoggedIn');
+        this.notifyLoggedOut = this._bind('notifyLoggedOut');
+        this.notifyChannelOpened = this._bind('notifyChannelOpened');
+        this.notifyChannelClosed = this._bind('notifyChannelClosed');
+        this.call = this._bind('call');
+        this.importSession = this._bind('importSession');
+        this.exportSession = this._bind('exportSession');
+        this.handleClientUpdate = this._bind('handleClientUpdate', true);
+        this.getApiCrenetials = this._bind('getApiCrenetials');
+        this.getPoolSize = this._bind('getPoolSize');
+        this.getPrimaryDcId = this._bind('getPrimaryDcId');
+        this.computeSrpParams = this._bind('computeSrpParams');
+        this.computeNewPasswordHash = this._bind('computeNewPasswordHash');
+        this.startUpdatesLoop = this._bind('startUpdatesLoop');
+        this.stopUpdatesLoop = this._bind('stopUpdatesLoop');
+    }
+    onServerUpdate(handler) {
+        this._serverUpdatesHandler = handler;
+    }
+    onError(handler) {
+        this._errorHandler = handler;
+    }
+    emitError(err) {
+        this._errorHandler(err);
+    }
+    onUpdate(handler) {
+        this._updateHandler = handler;
+    }
+    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(); // force cache self locally
+    }
+}
+exports.TelegramWorkerPort = TelegramWorkerPort;
+//# sourceMappingURL=port.js.map

package/cjs/highlevel/worker/port.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"port.js","sourceRoot":"","sources":["../../../../src/highlevel/worker/port.ts"],"names":[],"mappings":"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","sourcesContent":["import { tl } from '@mtcute/tl'\n\nimport { LogManager } from '../../utils/logger.js'\nimport { ITelegramClient } from '../client.types.js'\nimport { PeersIndex } from '../types/peers/peers-index.js'\nimport { RawUpdateHandler } from '../updates/types.js'\nimport { AppConfigManagerProxy } from './app-config.js'\nimport { WorkerInvoker } from './invoker.js'\nimport { connectToWorker } from './platform/connect.js'\nimport { ClientMessageHandler, SomeWorker, WorkerCustomMethods } from './protocol.js'\nimport { TelegramStorageProxy } from './storage.js'\n\nexport interface TelegramWorkerPortOptions {\n    worker: SomeWorker\n}\n\nexport class TelegramWorkerPort<Custom extends WorkerCustomMethods> implements ITelegramClient {\n    constructor(readonly options: TelegramWorkerPortOptions) {}\n\n    readonly log = new LogManager('worker')\n\n    private _serverUpdatesHandler: (updates: tl.TypeUpdates) => void = () => {}\n    onServerUpdate(handler: (updates: tl.TypeUpdates) => void): void {\n        this._serverUpdatesHandler = handler\n    }\n\n    private _errorHandler: (err: unknown) => void = () => {}\n    onError(handler: (err: unknown) => void): void {\n        this._errorHandler = handler\n    }\n    emitError(err: unknown): void {\n        this._errorHandler(err)\n    }\n\n    private _updateHandler: RawUpdateHandler = () => {}\n    onUpdate(handler: RawUpdateHandler): void {\n        this._updateHandler = handler\n    }\n\n    private _onMessage: ClientMessageHandler = (message) => {\n        switch (message.type) {\n            case 'log':\n                this.log.handler(message.color, message.level, message.tag, message.fmt, message.args)\n                break\n            case 'server_update':\n                this._serverUpdatesHandler(message.update)\n                break\n            case 'update': {\n                const peers = new PeersIndex(message.users, message.chats)\n                peers.hasMin = message.hasMin\n                this._updateHandler(message.update, peers)\n                break\n            }\n            case 'result':\n                this._invoker.handleResult(message)\n                break\n            case 'error':\n                this.emitError(message.error)\n                break\n        }\n    }\n\n    private _connection = connectToWorker(this.options.worker, this._onMessage)\n    private _invoker = new WorkerInvoker(this._connection[0])\n    private _bind = this._invoker.makeBinder<ITelegramClient>('client')\n\n    readonly storage = new TelegramStorageProxy(this._invoker)\n    readonly appConfig = new AppConfigManagerProxy(this._invoker)\n\n    private _destroyed = false\n    destroy(terminate = false): void {\n        if (this._destroyed) return\n        this._connection[1]()\n        this._destroyed = true\n\n        if (terminate && 'terminate' in this.options.worker) {\n            Promise.resolve(this.options.worker.terminate()).catch(() => {})\n        }\n    }\n\n    invokeCustom<T extends keyof Custom>(method: T, ...args: Parameters<Custom[T]>): Promise<ReturnType<Custom[T]>> {\n        return this._invoker.invoke('custom', method as string, args) as Promise<ReturnType<Custom[T]>>\n    }\n\n    readonly prepare = this._bind('prepare')\n    private _connect = this._bind('connect')\n    async connect(): Promise<void> {\n        await this._connect()\n        await this.storage.self.fetch() // force cache self locally\n    }\n    readonly close = this._bind('close')\n    readonly notifyLoggedIn = this._bind('notifyLoggedIn')\n    readonly notifyLoggedOut = this._bind('notifyLoggedOut')\n    readonly notifyChannelOpened = this._bind('notifyChannelOpened')\n    readonly notifyChannelClosed = this._bind('notifyChannelClosed')\n    readonly call = this._bind('call')\n    readonly importSession = this._bind('importSession')\n    readonly exportSession = this._bind('exportSession')\n    readonly handleClientUpdate = this._bind('handleClientUpdate', true)\n    readonly getApiCrenetials = this._bind('getApiCrenetials')\n    readonly getPoolSize = this._bind('getPoolSize')\n    readonly getPrimaryDcId = this._bind('getPrimaryDcId')\n    readonly computeSrpParams = this._bind('computeSrpParams')\n    readonly computeNewPasswordHash = this._bind('computeNewPasswordHash')\n    readonly startUpdatesLoop = this._bind('startUpdatesLoop')\n    readonly stopUpdatesLoop = this._bind('stopUpdatesLoop')\n}\n"]}

package/cjs/highlevel/worker/protocol.d.ts

@@ -0,0 +1,43 @@
+/// <reference types="node" resolution-mode="require"/>
+import type { Worker as NodeWorker } from 'worker_threads';
+import { tl } from '@mtcute/tl';
+import { SerializedError } from './errors.js';
+export type WorkerInboundMessage = {
+    type: 'invoke';
+    id: number;
+    target: 'custom' | 'client' | 'storage' | 'storage-self' | 'storage-peers' | 'app-config';
+    method: string;
+    args: unknown[];
+    void: boolean;
+};
+export type WorkerOutboundMessage = {
+    type: 'server_update';
+    update: tl.TypeUpdates;
+} | {
+    type: 'update';
+    update: tl.TypeUpdate;
+    users: Map<number, tl.TypeUser>;
+    chats: Map<number, tl.TypeChat>;
+    hasMin: boolean;
+} | {
+    type: 'error';
+    error: unknown;
+} | {
+    type: 'log';
+    color: number;
+    level: number;
+    tag: string;
+    fmt: string;
+    args: unknown[];
+} | {
+    type: 'result';
+    id: number;
+    result?: unknown;
+    error?: SerializedError;
+};
+export type SomeWorker = NodeWorker | Worker | SharedWorker;
+export type SendFn = (message: WorkerInboundMessage) => void;
+export type ClientMessageHandler = (message: WorkerOutboundMessage) => void;
+export type RespondFn = (message: WorkerOutboundMessage) => void;
+export type WorkerMessageHandler = (message: WorkerInboundMessage, respond: RespondFn) => void;
+export type WorkerCustomMethods = Record<string, (...args: unknown[]) => Promise<unknown>>;

package/cjs/highlevel/worker/protocol.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=protocol.js.map

package/cjs/highlevel/worker/protocol.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"protocol.js","sourceRoot":"","sources":["../../../../src/highlevel/worker/protocol.ts"],"names":[],"mappings":"","sourcesContent":["import type { Worker as NodeWorker } from 'worker_threads'\n\nimport { tl } from '@mtcute/tl'\n\nimport { SerializedError } from './errors.js'\n\nexport type WorkerInboundMessage = {\n    type: 'invoke'\n    id: number\n    target: 'custom' | 'client' | 'storage' | 'storage-self' | 'storage-peers' | 'app-config'\n    method: string\n    args: unknown[]\n    void: boolean\n}\n\nexport type WorkerOutboundMessage =\n    | { type: 'server_update'; update: tl.TypeUpdates }\n    | {\n          type: 'update'\n          update: tl.TypeUpdate\n          users: Map<number, tl.TypeUser>\n          chats: Map<number, tl.TypeChat>\n          hasMin: boolean\n      }\n    | { type: 'error'; error: unknown }\n    | {\n          type: 'log'\n          color: number\n          level: number\n          tag: string\n          fmt: string\n          args: unknown[]\n      }\n    | {\n          type: 'result'\n          id: number\n          result?: unknown\n          error?: SerializedError\n      }\n\nexport type SomeWorker = NodeWorker | Worker | SharedWorker\n\nexport type SendFn = (message: WorkerInboundMessage) => void\nexport type ClientMessageHandler = (message: WorkerOutboundMessage) => void\n\nexport type RespondFn = (message: WorkerOutboundMessage) => void\nexport type WorkerMessageHandler = (message: WorkerInboundMessage, respond: RespondFn) => void\n\nexport type WorkerCustomMethods = Record<string, (...args: unknown[]) => Promise<unknown>>\n"]}

package/cjs/highlevel/worker/storage.d.ts

@@ -0,0 +1,43 @@
+import { tl } from '@mtcute/tl';
+import { PublicPart } from '../../types/utils.js';
+import type { CurrentUserInfo, CurrentUserService } from '../storage/service/current-user.js';
+import type { PeersService } from '../storage/service/peers.js';
+import { TelegramStorageManager } from '../storage/storage.js';
+import { WorkerInvoker } from './invoker.js';
+declare class CurrentUserServiceProxy implements PublicPart<CurrentUserService> {
+    private _invoker;
+    constructor(_invoker: WorkerInvoker);
+    private _bind;
+    private _cached?;
+    private _store;
+    store(info: CurrentUserInfo | null): Promise<void>;
+    private _storeFrom;
+    storeFrom(user: tl.TypeUser): Promise<CurrentUserInfo>;
+    private _fetch;
+    fetch(): Promise<CurrentUserInfo | null>;
+    getCached(safe?: boolean): CurrentUserInfo | null;
+    private _update;
+    update(params: Parameters<CurrentUserService['update']>[0]): Promise<void>;
+}
+declare class PeersServiceProxy implements PublicPart<PeersService> {
+    private _invoker;
+    constructor(_invoker: WorkerInvoker);
+    private _bind;
+    readonly updatePeersFrom: (obj: tl.TlObject | tl.TlObject[]) => Promise<boolean>;
+    readonly store: (peer: tl.TypeUser | tl.TypeChat) => Promise<void>;
+    readonly getById: (id: number, allowRefs?: boolean) => Promise<tl.TypeInputPeer | null>;
+    readonly getByPhone: (phone: string) => Promise<tl.TypeInputPeer | null>;
+    readonly getByUsername: (username: string) => Promise<tl.TypeInputPeer | null>;
+    readonly getCompleteById: (id: number) => Promise<tl.TypeUser | tl.TypeChat | null>;
+}
+export declare class TelegramStorageProxy implements PublicPart<TelegramStorageManager> {
+    private _invoker;
+    constructor(_invoker: WorkerInvoker);
+    private _bind;
+    readonly updates: never;
+    readonly refMsgs: never;
+    readonly self: CurrentUserServiceProxy;
+    readonly peers: PeersServiceProxy;
+    readonly clear: (withAuthKeys?: boolean) => Promise<void>;
+}
+export {};

package/cjs/highlevel/worker/storage.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TelegramStorageProxy = void 0;
+const errors_js_1 = require("../../types/errors.js");
+class CurrentUserServiceProxy {
+    constructor(_invoker) {
+        this._invoker = _invoker;
+        this._bind = this._invoker.makeBinder('storage-self');
+        this._store = this._bind('store');
+        this._storeFrom = this._bind('storeFrom');
+        this._fetch = this._bind('fetch');
+        this._update = this._bind('update');
+    }
+    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 === undefined) {
+            if (safe)
+                return null;
+            throw new errors_js_1.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;
+        this._bind = this._invoker.makeBinder('storage-peers');
+        this.updatePeersFrom = this._bind('updatePeersFrom');
+        this.store = this._bind('store');
+        this.getById = this._bind('getById');
+        this.getByPhone = this._bind('getByPhone');
+        this.getByUsername = this._bind('getByUsername');
+        this.getCompleteById = this._bind('getCompleteById');
+    }
+}
+class TelegramStorageProxy {
+    constructor(_invoker) {
+        this._invoker = _invoker;
+        this._bind = this._invoker.makeBinder('storage');
+        // todo - remove once we move these to updates manager
+        this.updates = null;
+        this.refMsgs = null;
+        this.self = new CurrentUserServiceProxy(this._invoker);
+        this.peers = new PeersServiceProxy(this._invoker);
+        this.clear = this._bind('clear');
+    }
+}
+exports.TelegramStorageProxy = TelegramStorageProxy;
+//# sourceMappingURL=storage.js.map

package/cjs/highlevel/worker/storage.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"storage.js","sourceRoot":"","sources":["../../../../src/highlevel/worker/storage.ts"],"names":[],"mappings":";;;AAEA,qDAAuD;AAOvD,MAAM,uBAAuB;IACzB,YAAoB,QAAuB;QAAvB,aAAQ,GAAR,QAAQ,CAAe;QACnC,UAAK,GAAG,IAAI,CAAC,QAAQ,CAAC,UAAU,CAAqB,cAAc,CAAC,CAAA;QAIpE,WAAM,GAAG,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,CAAA;QAM5B,eAAU,GAAG,IAAI,CAAC,KAAK,CAAC,WAAW,CAAC,CAAA;QAOpC,WAAM,GAAG,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,CAAA;QAmB5B,YAAO,GAAG,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAA;IArCQ,CAAC;IAM/C,KAAK,CAAC,KAAK,CAAC,IAA4B;QACpC,MAAM,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,CAAA;QACvB,IAAI,CAAC,OAAO,GAAG,IAAI,CAAA;IACvB,CAAC;IAGD,KAAK,CAAC,SAAS,CAAC,IAAiB;QAC7B,IAAI,CAAC,OAAO,GAAG,MAAM,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,CAAA;QAE1C,OAAO,IAAI,CAAC,OAAO,CAAA;IACvB,CAAC;IAGD,KAAK,CAAC,KAAK;QACP,IAAI,IAAI,CAAC,OAAO;YAAE,OAAO,IAAI,CAAC,OAAO,CAAA;QAErC,IAAI,CAAC,OAAO,GAAG,MAAM,IAAI,CAAC,MAAM,EAAE,CAAA;QAElC,OAAO,IAAI,CAAC,OAAO,CAAA;IACvB,CAAC;IAED,SAAS,CAAC,IAAc;QACpB,IAAI,IAAI,CAAC,OAAO,KAAK,SAAS,EAAE;YAC5B,IAAI,IAAI;gBAAE,OAAO,IAAI,CAAA;YAErB,MAAM,IAAI,2BAAe,CAAC,6BAA6B,CAAC,CAAA;SAC3D;QAED,OAAO,IAAI,CAAC,OAAO,CAAA;IACvB,CAAC;IAGD,KAAK,CAAC,MAAM,CAAC,MAAmD;QAC5D,MAAM,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,CAAA;QAC1B,IAAI,CAAC,OAAO,GAAG,MAAM,IAAI,CAAC,MAAM,EAAE,CAAA;IACtC,CAAC;CACJ;AAED,MAAM,iBAAiB;IACnB,YAAoB,QAAuB;QAAvB,aAAQ,GAAR,QAAQ,CAAe;QACnC,UAAK,GAAG,IAAI,CAAC,QAAQ,CAAC,UAAU,CAAe,eAAe,CAAC,CAAA;QAE9D,oBAAe,GAAG,IAAI,CAAC,KAAK,CAAC,iBAAiB,CAAC,CAAA;QAC/C,UAAK,GAAG,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,CAAA;QAC3B,YAAO,GAAG,IAAI,CAAC,KAAK,CAAC,SAAS,CAAC,CAAA;QAC/B,eAAU,GAAG,IAAI,CAAC,KAAK,CAAC,YAAY,CAAC,CAAA;QACrC,kBAAa,GAAG,IAAI,CAAC,KAAK,CAAC,eAAe,CAAC,CAAA;QAC3C,oBAAe,GAAG,IAAI,CAAC,KAAK,CAAC,iBAAiB,CAAC,CAAA;IARV,CAAC;CASlD;AAED,MAAa,oBAAoB;IAC7B,YAAoB,QAAuB;QAAvB,aAAQ,GAAR,QAAQ,CAAe;QAEnC,UAAK,GAAG,IAAI,CAAC,QAAQ,CAAC,UAAU,CAAyB,SAAS,CAAC,CAAA;QAE3E,sDAAsD;QAC7C,YAAO,GAAG,IAAa,CAAA;QACvB,YAAO,GAAG,IAAa,CAAA;QAEvB,SAAI,GAAG,IAAI,uBAAuB,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAA;QACjD,UAAK,GAAG,IAAI,iBAAiB,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAA;QAE5C,UAAK,GAAG,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,CAAA;IAXU,CAAC;CAYlD;AAbD,oDAaC","sourcesContent":["import { tl } from '@mtcute/tl'\n\nimport { MtArgumentError } from '../../types/errors.js'\nimport { PublicPart } from '../../types/utils.js'\nimport type { CurrentUserInfo, CurrentUserService } from '../storage/service/current-user.js'\nimport type { PeersService } from '../storage/service/peers.js'\nimport { TelegramStorageManager } from '../storage/storage.js'\nimport { WorkerInvoker } from './invoker.js'\n\nclass CurrentUserServiceProxy implements PublicPart<CurrentUserService> {\n    constructor(private _invoker: WorkerInvoker) {}\n    private _bind = this._invoker.makeBinder<CurrentUserService>('storage-self')\n\n    private _cached?: CurrentUserInfo | null\n\n    private _store = this._bind('store')\n    async store(info: CurrentUserInfo | null): Promise<void> {\n        await this._store(info)\n        this._cached = info\n    }\n\n    private _storeFrom = this._bind('storeFrom')\n    async storeFrom(user: tl.TypeUser): Promise<CurrentUserInfo> {\n        this._cached = await this._storeFrom(user)\n\n        return this._cached\n    }\n\n    private _fetch = this._bind('fetch')\n    async fetch(): Promise<CurrentUserInfo | null> {\n        if (this._cached) return this._cached\n\n        this._cached = await this._fetch()\n\n        return this._cached\n    }\n\n    getCached(safe?: boolean): CurrentUserInfo | null {\n        if (this._cached === undefined) {\n            if (safe) return null\n\n            throw new MtArgumentError('User info is not cached yet')\n        }\n\n        return this._cached\n    }\n\n    private _update = this._bind('update')\n    async update(params: Parameters<CurrentUserService['update']>[0]): Promise<void> {\n        await this._update(params)\n        this._cached = await this._fetch()\n    }\n}\n\nclass PeersServiceProxy implements PublicPart<PeersService> {\n    constructor(private _invoker: WorkerInvoker) {}\n    private _bind = this._invoker.makeBinder<PeersService>('storage-peers')\n\n    readonly updatePeersFrom = this._bind('updatePeersFrom')\n    readonly store = this._bind('store')\n    readonly getById = this._bind('getById')\n    readonly getByPhone = this._bind('getByPhone')\n    readonly getByUsername = this._bind('getByUsername')\n    readonly getCompleteById = this._bind('getCompleteById')\n}\n\nexport class TelegramStorageProxy implements PublicPart<TelegramStorageManager> {\n    constructor(private _invoker: WorkerInvoker) {}\n\n    private _bind = this._invoker.makeBinder<TelegramStorageManager>('storage')\n\n    // todo - remove once we move these to updates manager\n    readonly updates = null as never\n    readonly refMsgs = null as never\n\n    readonly self = new CurrentUserServiceProxy(this._invoker)\n    readonly peers = new PeersServiceProxy(this._invoker)\n\n    readonly clear = this._bind('clear')\n}\n"]}

package/cjs/highlevel/worker/worker.d.ts

@@ -0,0 +1,7 @@
+import { BaseTelegramClient, BaseTelegramClientOptions } from '../base.js';
+import { WorkerCustomMethods } from './protocol.js';
+export interface TelegramWorkerOptions<T extends WorkerCustomMethods> {
+    client: BaseTelegramClient | BaseTelegramClientOptions;
+    customMethods?: T;
+}
+export declare function makeTelegramWorker<T extends WorkerCustomMethods>(params: TelegramWorkerOptions<T>): void;