@mtcute/core 0.17.0 → 0.18.0-rc.5

package/storage/sqlite/repository/peers.cjs

@@ -0,0 +1,102 @@
+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 errors = require("../../../types/errors.cjs");
+function mapPeerDto(dto) {
+  return {
+    id: dto.id,
+    accessHash: dto.hash,
+    isMin: dto.isMin === 1,
+    usernames: JSON.parse(dto.usernames),
+    updated: dto.updated,
+    phone: dto.phone || void 0,
+    complete: dto.complete
+  };
+}
+class SqlitePeersRepository {
+  constructor(_driver) {
+    this._driver = _driver;
+    _driver.registerMigration("peers", 1, (db) => {
+      db.exec(`
+                create table peers (
+                    id integer primary key,
+                    hash text not null,
+                    usernames json not null,
+                    updated integer not null,
+                    phone text,
+                    complete blob
+                );
+                create index idx_peers_usernames on peers (usernames);
+                create index idx_peers_phone on peers (phone);
+            `);
+    });
+    _driver.registerMigration("peers", 2, (db) => {
+      db.exec("alter table peers add column isMin integer not null default false;");
+    });
+    _driver.onLoad((db) => {
+      this._loaded = true;
+      this._store = db.prepare(
+        "insert or replace into peers (id, hash, isMin, usernames, updated, phone, complete) values (?, ?, ?, ?, ?, ?, ?)"
+      );
+      this._getById = db.prepare("select * from peers where id = ? and isMin = false");
+      this._getByIdAllowMin = db.prepare("select * from peers where id = ?");
+      this._getByUsername = db.prepare(
+        "select * from peers where exists (select 1 from json_each(usernames) where value = ?) and isMin = false"
+      );
+      this._getByPhone = db.prepare("select * from peers where phone = ? and isMin = false");
+      this._delAll = db.prepare("delete from peers");
+    });
+    _driver.registerLegacyMigration("peers", (db) => {
+      db.exec("drop table entities");
+    });
+  }
+  _loaded = false;
+  _ensureLoaded() {
+    if (!this._loaded) {
+      throw new errors.MtcuteError("Peers repository is not loaded. Have you called client.start() (or similar)?");
+    }
+  }
+  _store;
+  store(peer) {
+    this._driver._writeLater(this._store, [
+      peer.id,
+      peer.accessHash,
+      peer.isMin ? 1 : 0,
+      JSON.stringify(peer.usernames),
+      peer.updated,
+      peer.phone ?? null,
+      peer.complete
+    ]);
+  }
+  _getById;
+  _getByIdAllowMin;
+  getById(id, allowMin) {
+    this._ensureLoaded();
+    const row = (allowMin ? this._getByIdAllowMin : this._getById).get(id);
+    if (!row) return null;
+    return mapPeerDto(row);
+  }
+  _getByUsername;
+  getByUsername(username) {
+    this._ensureLoaded();
+    const row = this._getByUsername.get(username);
+    if (!row) return null;
+    return mapPeerDto(row);
+  }
+  _getByPhone;
+  getByPhone(phone) {
+    this._ensureLoaded();
+    const row = this._getByPhone.get(phone);
+    if (!row) return null;
+    return mapPeerDto(row);
+  }
+  _delAll;
+  deleteAll() {
+    this._delAll.run();
+  }
+}
+exports.SqlitePeersRepository = SqlitePeersRepository;

package/storage/sqlite/repository/peers.js

@@ -0,0 +1,97 @@
+import { MtcuteError } from "../../../types/errors.js";
+function mapPeerDto(dto) {
+  return {
+    id: dto.id,
+    accessHash: dto.hash,
+    isMin: dto.isMin === 1,
+    usernames: JSON.parse(dto.usernames),
+    updated: dto.updated,
+    phone: dto.phone || void 0,
+    complete: dto.complete
+  };
+}
+class SqlitePeersRepository {
+  constructor(_driver) {
+    this._driver = _driver;
+    _driver.registerMigration("peers", 1, (db) => {
+      db.exec(`
+                create table peers (
+                    id integer primary key,
+                    hash text not null,
+                    usernames json not null,
+                    updated integer not null,
+                    phone text,
+                    complete blob
+                );
+                create index idx_peers_usernames on peers (usernames);
+                create index idx_peers_phone on peers (phone);
+            `);
+    });
+    _driver.registerMigration("peers", 2, (db) => {
+      db.exec("alter table peers add column isMin integer not null default false;");
+    });
+    _driver.onLoad((db) => {
+      this._loaded = true;
+      this._store = db.prepare(
+        "insert or replace into peers (id, hash, isMin, usernames, updated, phone, complete) values (?, ?, ?, ?, ?, ?, ?)"
+      );
+      this._getById = db.prepare("select * from peers where id = ? and isMin = false");
+      this._getByIdAllowMin = db.prepare("select * from peers where id = ?");
+      this._getByUsername = db.prepare(
+        "select * from peers where exists (select 1 from json_each(usernames) where value = ?) and isMin = false"
+      );
+      this._getByPhone = db.prepare("select * from peers where phone = ? and isMin = false");
+      this._delAll = db.prepare("delete from peers");
+    });
+    _driver.registerLegacyMigration("peers", (db) => {
+      db.exec("drop table entities");
+    });
+  }
+  _loaded = false;
+  _ensureLoaded() {
+    if (!this._loaded) {
+      throw new MtcuteError("Peers repository is not loaded. Have you called client.start() (or similar)?");
+    }
+  }
+  _store;
+  store(peer) {
+    this._driver._writeLater(this._store, [
+      peer.id,
+      peer.accessHash,
+      peer.isMin ? 1 : 0,
+      JSON.stringify(peer.usernames),
+      peer.updated,
+      peer.phone ?? null,
+      peer.complete
+    ]);
+  }
+  _getById;
+  _getByIdAllowMin;
+  getById(id, allowMin) {
+    this._ensureLoaded();
+    const row = (allowMin ? this._getByIdAllowMin : this._getById).get(id);
+    if (!row) return null;
+    return mapPeerDto(row);
+  }
+  _getByUsername;
+  getByUsername(username) {
+    this._ensureLoaded();
+    const row = this._getByUsername.get(username);
+    if (!row) return null;
+    return mapPeerDto(row);
+  }
+  _getByPhone;
+  getByPhone(phone) {
+    this._ensureLoaded();
+    const row = this._getByPhone.get(phone);
+    if (!row) return null;
+    return mapPeerDto(row);
+  }
+  _delAll;
+  deleteAll() {
+    this._delAll.run();
+  }
+}
+export {
+  SqlitePeersRepository
+};

package/storage/sqlite/repository/ref-messages.cjs

@@ -0,0 +1,58 @@
+if (typeof globalThis !== "undefined" && !globalThis._MTCUTE_CJS_DEPRECATION_WARNED) {
+  globalThis._MTCUTE_CJS_DEPRECATION_WARNED = true;
+  console.warn("[mtcute-workspace] CommonJS support is deprecated and will be removed in 0.20.0. Please consider switching to ESM, it's " + (/* @__PURE__ */ new Date()).getFullYear() + " already.");
+  console.warn("[mtcute-workspace] Learn more about switching to ESM: https://gist.github.com/sindresorhus/a39789f98801d908bbc7ff3ecc99d99c");
+}
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+class SqliteRefMessagesRepository {
+  constructor(_driver) {
+    this._driver = _driver;
+    _driver.registerMigration("ref_messages", 1, (db) => {
+      db.exec(`
+                create table if not exists message_refs (
+                    peer_id integer not null,
+                    chat_id integer not null,
+                    msg_id integer not null
+                );
+                create index if not exists idx_message_refs_peer on message_refs (peer_id);
+                create index if not exists idx_message_refs on message_refs (chat_id, msg_id);
+            `);
+    });
+    _driver.onLoad(() => {
+      this._store = this._driver.db.prepare(
+        "insert or replace into message_refs (peer_id, chat_id, msg_id) values (?, ?, ?)"
+      );
+      this._getByPeer = this._driver.db.prepare("select chat_id, msg_id from message_refs where peer_id = ?");
+      this._del = this._driver.db.prepare("delete from message_refs where chat_id = ? and msg_id = ?");
+      this._delByPeer = this._driver.db.prepare("delete from message_refs where peer_id = ?");
+      this._delAll = this._driver.db.prepare("delete from message_refs");
+    });
+  }
+  _store;
+  store(peerId, chatId, msgId) {
+    this._store.run(peerId, chatId, msgId);
+  }
+  _getByPeer;
+  getByPeer(peerId) {
+    const res = this._getByPeer.get(peerId);
+    if (!res) return null;
+    const res_ = res;
+    return [res_.chat_id, res_.msg_id];
+  }
+  _del;
+  delete(chatId, msgIds) {
+    for (const msgId of msgIds) {
+      this._driver._writeLater(this._del, [chatId, msgId]);
+    }
+  }
+  _delByPeer;
+  deleteByPeer(peerId) {
+    this._delByPeer.run(peerId);
+  }
+  _delAll;
+  deleteAll() {
+    this._delAll.run();
+  }
+}
+exports.SqliteRefMessagesRepository = SqliteRefMessagesRepository;

package/storage/sqlite/repository/ref-messages.js

@@ -0,0 +1,53 @@
+class SqliteRefMessagesRepository {
+  constructor(_driver) {
+    this._driver = _driver;
+    _driver.registerMigration("ref_messages", 1, (db) => {
+      db.exec(`
+                create table if not exists message_refs (
+                    peer_id integer not null,
+                    chat_id integer not null,
+                    msg_id integer not null
+                );
+                create index if not exists idx_message_refs_peer on message_refs (peer_id);
+                create index if not exists idx_message_refs on message_refs (chat_id, msg_id);
+            `);
+    });
+    _driver.onLoad(() => {
+      this._store = this._driver.db.prepare(
+        "insert or replace into message_refs (peer_id, chat_id, msg_id) values (?, ?, ?)"
+      );
+      this._getByPeer = this._driver.db.prepare("select chat_id, msg_id from message_refs where peer_id = ?");
+      this._del = this._driver.db.prepare("delete from message_refs where chat_id = ? and msg_id = ?");
+      this._delByPeer = this._driver.db.prepare("delete from message_refs where peer_id = ?");
+      this._delAll = this._driver.db.prepare("delete from message_refs");
+    });
+  }
+  _store;
+  store(peerId, chatId, msgId) {
+    this._store.run(peerId, chatId, msgId);
+  }
+  _getByPeer;
+  getByPeer(peerId) {
+    const res = this._getByPeer.get(peerId);
+    if (!res) return null;
+    const res_ = res;
+    return [res_.chat_id, res_.msg_id];
+  }
+  _del;
+  delete(chatId, msgIds) {
+    for (const msgId of msgIds) {
+      this._driver._writeLater(this._del, [chatId, msgId]);
+    }
+  }
+  _delByPeer;
+  deleteByPeer(peerId) {
+    this._delByPeer.run(peerId);
+  }
+  _delAll;
+  deleteAll() {
+    this._delAll.run();
+  }
+}
+export {
+  SqliteRefMessagesRepository
+};

package/storage/storage.cjs

@@ -0,0 +1,74 @@
+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 defaultDcs = require("./service/default-dcs.cjs");
+const functionUtils = require("../utils/function-utils.cjs");
+require("@mtcute/tl-runtime");
+const authKeys = require("./service/auth-keys.cjs");
+const futureSalts = require("./service/future-salts.cjs");
+class StorageManager {
+  constructor(options) {
+    this.options = options;
+    this.provider = this.options.provider;
+    this.platform = this.options.platform;
+    this.driver = this.provider.driver;
+    this.log = this.options.log.create("storage");
+    const serviceOptions = {
+      driver: this.driver,
+      readerMap: this.options.readerMap,
+      writerMap: this.options.writerMap,
+      log: this.log
+    };
+    this.dcs = new defaultDcs.DefaultDcsService(this.provider.kv, serviceOptions);
+    this.salts = new futureSalts.FutureSaltsService(this.provider.kv, serviceOptions);
+    this.keys = new authKeys.AuthKeysService(this.provider.authKeys, this.salts, serviceOptions);
+  }
+  provider;
+  driver;
+  platform;
+  log;
+  dcs;
+  salts;
+  keys;
+  _cleanupRestore;
+  _load = functionUtils.asyncResettable(async () => {
+    this.driver.setup?.(this.log, this.platform);
+    if (this.options.cleanup ?? true) {
+      this._cleanupRestore = this.platform.beforeExit(() => {
+        this._destroy().catch((err) => this.log.error("cleanup error: %e", err));
+      });
+    }
+    await this.driver.load?.();
+  });
+  load() {
+    return this._load.run();
+  }
+  async save() {
+    await this.driver.save?.();
+  }
+  async clear(withAuthKeys = false) {
+    if (withAuthKeys) {
+      await this.provider.authKeys.deleteAll();
+    }
+    await this.provider.kv.deleteAll();
+    await this.save();
+  }
+  async _destroy() {
+    if (!this._load.finished()) return;
+    await this._load.wait();
+    await this.driver.destroy?.();
+    this._load.reset();
+  }
+  async destroy() {
+    if (this._cleanupRestore) {
+      this._cleanupRestore();
+      this._cleanupRestore = void 0;
+    }
+    await this._destroy();
+  }
+}
+exports.StorageManager = StorageManager;

package/storage/storage.d.ts

@@ -1,12 +1,14 @@
 import { TlReaderMap, TlWriterMap } from '@mtcute/tl-runtime';
+import { ICorePlatform } from '../types/platform.js';
 import { Logger } from '../utils/logger.js';
+import { IStorageDriver } from './driver.js';
 import { IMtStorageProvider } from './provider.js';
 import { AuthKeysService } from './service/auth-keys.js';
 import { DefaultDcsService } from './service/default-dcs.js';
 import { FutureSaltsService } from './service/future-salts.js';
-import { IStorageDriver } from './driver.js';
 interface StorageManagerOptions {
     provider: IMtStorageProvider;
+    platform: ICorePlatform;
     log: Logger;
     readerMap: TlReaderMap;
     writerMap: TlWriterMap;
@@ -36,6 +38,7 @@ export declare class StorageManager {
     readonly options: StorageManagerOptions & StorageManagerExtraOptions;
     readonly provider: IMtStorageProvider;
     readonly driver: IStorageDriver;
+    readonly platform: ICorePlatform;
     readonly log: Logger;
     readonly dcs: DefaultDcsService;
     readonly salts: FutureSaltsService;

package/storage/storage.js

@@ -0,0 +1,69 @@
+import { DefaultDcsService } from "./service/default-dcs.js";
+import { asyncResettable } from "../utils/function-utils.js";
+import "@mtcute/tl-runtime";
+import { AuthKeysService } from "./service/auth-keys.js";
+import { FutureSaltsService } from "./service/future-salts.js";
+class StorageManager {
+  constructor(options) {
+    this.options = options;
+    this.provider = this.options.provider;
+    this.platform = this.options.platform;
+    this.driver = this.provider.driver;
+    this.log = this.options.log.create("storage");
+    const serviceOptions = {
+      driver: this.driver,
+      readerMap: this.options.readerMap,
+      writerMap: this.options.writerMap,
+      log: this.log
+    };
+    this.dcs = new DefaultDcsService(this.provider.kv, serviceOptions);
+    this.salts = new FutureSaltsService(this.provider.kv, serviceOptions);
+    this.keys = new AuthKeysService(this.provider.authKeys, this.salts, serviceOptions);
+  }
+  provider;
+  driver;
+  platform;
+  log;
+  dcs;
+  salts;
+  keys;
+  _cleanupRestore;
+  _load = asyncResettable(async () => {
+    this.driver.setup?.(this.log, this.platform);
+    if (this.options.cleanup ?? true) {
+      this._cleanupRestore = this.platform.beforeExit(() => {
+        this._destroy().catch((err) => this.log.error("cleanup error: %e", err));
+      });
+    }
+    await this.driver.load?.();
+  });
+  load() {
+    return this._load.run();
+  }
+  async save() {
+    await this.driver.save?.();
+  }
+  async clear(withAuthKeys = false) {
+    if (withAuthKeys) {
+      await this.provider.authKeys.deleteAll();
+    }
+    await this.provider.kv.deleteAll();
+    await this.save();
+  }
+  async _destroy() {
+    if (!this._load.finished()) return;
+    await this._load.wait();
+    await this.driver.destroy?.();
+    this._load.reset();
+  }
+  async destroy() {
+    if (this._cleanupRestore) {
+      this._cleanupRestore();
+      this._cleanupRestore = void 0;
+    }
+    await this._destroy();
+  }
+}
+export {
+  StorageManager
+};

package/{chunks/cjs/j7rWn_1y.js → types/errors.cjs}

@@ -1,10 +1,10 @@
 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";
-const tlRuntime = require("@mtcute/tl-runtime");
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 class MtcuteError extends Error {
 }
 class MtArgumentError extends MtcuteError {
@@ -39,31 +39,9 @@ class MtTimeoutError extends MtcuteError {
     this.timeout = timeout;
   }
 }
-const platformKey = typeof Symbol !== "undefined" ? Symbol.for("mtcute.platform") : "__MTCUTE_PLATFORM__";
-let _platform = globalThis?.[platformKey] ?? null;
-function setPlatform(platform) {
-  if (_platform) {
-    if (_platform.constructor !== platform.constructor) {
-      throw new MtUnsupportedError("Platform may not be changed at runtime!");
-    }
-    return;
-  }
-  _platform = platform;
-  tlRuntime.TlBinaryReader.platform = platform;
-  tlRuntime.TlBinaryWriter.platform = platform;
-  globalThis[platformKey] = platform;
-}
-function getPlatform() {
-  if (!_platform) {
-    throw new MtUnsupportedError("Platform is not set! Have you instantiated the client?");
-  }
-  return _platform;
-}
 exports.MtArgumentError = MtArgumentError;
 exports.MtSecurityError = MtSecurityError;
 exports.MtTimeoutError = MtTimeoutError;
 exports.MtTypeAssertionError = MtTypeAssertionError;
 exports.MtUnsupportedError = MtUnsupportedError;
 exports.MtcuteError = MtcuteError;
-exports.getPlatform = getPlatform;
-exports.setPlatform = setPlatform;

package/{chunks/es/DBMBgE7t.js → types/errors.js}

@@ -1,4 +1,3 @@
-import { TlBinaryReader, TlBinaryWriter } from "@mtcute/tl-runtime";
 class MtcuteError extends Error {
 }
 class MtArgumentError extends MtcuteError {
@@ -33,33 +32,11 @@ class MtTimeoutError extends MtcuteError {
     this.timeout = timeout;
   }
 }
-const platformKey = typeof Symbol !== "undefined" ? Symbol.for("mtcute.platform") : "__MTCUTE_PLATFORM__";
-let _platform = globalThis?.[platformKey] ?? null;
-function setPlatform(platform) {
-  if (_platform) {
-    if (_platform.constructor !== platform.constructor) {
-      throw new MtUnsupportedError("Platform may not be changed at runtime!");
-    }
-    return;
-  }
-  _platform = platform;
-  TlBinaryReader.platform = platform;
-  TlBinaryWriter.platform = platform;
-  globalThis[platformKey] = platform;
-}
-function getPlatform() {
-  if (!_platform) {
-    throw new MtUnsupportedError("Platform is not set! Have you instantiated the client?");
-  }
-  return _platform;
-}
 export {
   MtArgumentError,
   MtSecurityError,
   MtTimeoutError,
   MtTypeAssertionError,
   MtUnsupportedError,
-  MtcuteError,
-  getPlatform,
-  setPlatform
+  MtcuteError
 };

package/types/index.d.ts

@@ -1,3 +1,4 @@
 export * from './errors.js';
 export * from './peers.js';
+export * from './platform.js';
 export * from './utils.js';

package/{platform.d.ts → types/platform.d.ts}

@@ -1,7 +1,6 @@
-import { ITlPlatform } from '@mtcute/tl-runtime';
-import { UploadFileLike } from './highlevel/types/files/utils.js';
-import { MaybePromise } from './types/index.js';
-export interface ICorePlatform extends ITlPlatform {
+import { UploadFileLike } from '../highlevel/types/files/utils.js';
+import { MaybePromise } from './index.js';
+export interface ICorePlatform {
     beforeExit: (fn: () => void) => () => void;
     log: (color: number, level: number, tag: string, fmt: string, args: unknown[]) => void;
     getDefaultLogLevel: () => number | null;
@@ -14,5 +13,3 @@ export interface ICorePlatform extends ITlPlatform {
     onNetworkChanged?: (fn: (connected: boolean) => void) => () => void;
     isOnline?: () => boolean;
 }
-export declare function setPlatform(platform: ICorePlatform): void;
-export declare function getPlatform(): ICorePlatform;

package/types/utils.cjs

@@ -0,0 +1,11 @@
+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" });
+function assertNever(_) {
+  throw new Error("Illegal state");
+}
+exports.assertNever = assertNever;

package/types/utils.d.ts

@@ -1,8 +1,7 @@
-export type MaybePromise<T> = T | Promise<T>;
+export type { MaybeArray, MaybePromise } from '@fuman/utils';
 export type PartialExcept<T, K extends keyof T> = Partial<Omit<T, K>> & Pick<T, K>;
 export type PartialOnly<T, K extends keyof T> = Partial<Pick<T, K>> & Omit<T, K>;
 export type AnyToNever<T> = any extends T ? never : T;
-export type MaybeArray<T> = T | T[];
 export type MustEqual<T, V> = (() => T) extends () => V ? ((() => V) extends () => T ? T : V) : V;
 export type PublicPart<T> = {
     [K in keyof T]: T[K];

package/types/utils.js

@@ -0,0 +1,6 @@
+function assertNever(_) {
+  throw new Error("Illegal state");
+}
+export {
+  assertNever
+};

package/utils/abort-signal.cjs

@@ -0,0 +1,23 @@
+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" });
+function combineAbortSignals(signal1, signal2) {
+  if (!signal2) return signal1;
+  if (typeof AbortSignal.any === "function") {
+    return AbortSignal.any([signal1, signal2]);
+  }
+  const controller = new AbortController();
+  function abort() {
+    controller.abort(this.reason);
+    signal1.removeEventListener("abort", abort);
+    signal2.removeEventListener("abort", abort);
+  }
+  signal1.addEventListener("abort", abort);
+  signal2.addEventListener("abort", abort);
+  return controller.signal;
+}
+exports.combineAbortSignals = combineAbortSignals;

package/utils/abort-signal.js

@@ -0,0 +1,18 @@
+function combineAbortSignals(signal1, signal2) {
+  if (!signal2) return signal1;
+  if (typeof AbortSignal.any === "function") {
+    return AbortSignal.any([signal1, signal2]);
+  }
+  const controller = new AbortController();
+  function abort() {
+    controller.abort(this.reason);
+    signal1.removeEventListener("abort", abort);
+    signal2.removeEventListener("abort", abort);
+  }
+  signal1.addEventListener("abort", abort);
+  signal2.addEventListener("abort", abort);
+  return controller.signal;
+}
+export {
+  combineAbortSignals
+};