@mtcute/dispatcher 0.17.2 → 0.18.0

package/filters/state.cjs

@@ -0,0 +1,21 @@
+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 stateEmpty = async (upd, state2) => {
+  if (!state2) return false;
+  return !await state2.get();
+};
+function state(predicate) {
+  return async (upd, state2) => {
+    if (!state2) return false;
+    const data = await state2.get();
+    if (!data) return false;
+    return predicate(data);
+  };
+}
+exports.state = state;
+exports.stateEmpty = stateEmpty;

package/filters/state.d.cts

@@ -0,0 +1,15 @@
+import { MaybePromise } from '@mtcute/core';
+import { UpdateFilter } from './types.js';
+/**
+ * Create a filter for the cases when the state is empty
+ */
+export declare const stateEmpty: UpdateFilter<any>;
+/**
+ * Create a filter based on state predicate
+ *
+ * If state exists and matches `predicate`, update passes
+ * this filter, otherwise it doesn't
+ *
+ * @param predicate  State predicate
+ */
+export declare function state<T extends object>(predicate: (state: T) => MaybePromise<boolean>): UpdateFilter<any, {}, T>;

package/filters/state.js

@@ -0,0 +1,16 @@
+const stateEmpty = async (upd, state2) => {
+  if (!state2) return false;
+  return !await state2.get();
+};
+function state(predicate) {
+  return async (upd, state2) => {
+    if (!state2) return false;
+    const data = await state2.get();
+    if (!data) return false;
+    return predicate(data);
+  };
+}
+export {
+  state,
+  stateEmpty
+};

package/filters/text.cjs

@@ -0,0 +1,87 @@
+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 core = require("@mtcute/core");
+function extractText(obj) {
+  if (obj instanceof core.Message || obj instanceof core.BusinessMessage) {
+    return obj.text;
+  }
+  switch (obj._name) {
+    case "inline_query":
+      return obj.query;
+    case "chosen_inline_result":
+      return obj.id;
+    case "callback_query":
+    case "inline_callback_query":
+    case "business_callback_query":
+      if (obj.raw.data) return obj.dataStr;
+  }
+  return null;
+}
+function regex(regex2) {
+  return (obj) => {
+    const txt = extractText(obj);
+    if (!txt) return false;
+    const m = txt.match(regex2);
+    if (m) {
+      obj.match = m;
+      return true;
+    }
+    return false;
+  };
+}
+function equals(str, ignoreCase = false) {
+  if (ignoreCase) {
+    str = str.toLowerCase();
+    return (obj) => extractText(obj)?.toLowerCase() === str;
+  }
+  return (obj) => extractText(obj) === str;
+}
+function contains(str, ignoreCase = false) {
+  if (ignoreCase) {
+    str = str.toLowerCase();
+    return (obj) => {
+      const txt = extractText(obj);
+      return txt != null && txt.toLowerCase().includes(str);
+    };
+  }
+  return (obj) => {
+    const txt = extractText(obj);
+    return txt != null && txt.includes(str);
+  };
+}
+function startsWith(str, ignoreCase = false) {
+  if (ignoreCase) {
+    str = str.toLowerCase();
+    return (obj) => {
+      const txt = extractText(obj);
+      return txt != null && txt.toLowerCase().substring(0, str.length) === str;
+    };
+  }
+  return (obj) => {
+    const txt = extractText(obj);
+    return txt != null && txt.substring(0, str.length) === str;
+  };
+}
+function endsWith(str, ignoreCase = false) {
+  if (ignoreCase) {
+    str = str.toLowerCase();
+    return (obj) => {
+      const txt = extractText(obj);
+      return txt != null && txt.toLowerCase().substring(0, str.length) === str;
+    };
+  }
+  return (obj) => {
+    const txt = extractText(obj);
+    return txt != null && txt.substring(0, str.length) === str;
+  };
+}
+exports.contains = contains;
+exports.endsWith = endsWith;
+exports.equals = equals;
+exports.regex = regex;
+exports.startsWith = startsWith;

package/filters/text.d.cts

@@ -0,0 +1,64 @@
+import { BusinessCallbackQuery, CallbackQuery, ChosenInlineResult, InlineCallbackQuery, InlineQuery, BusinessMessage, Message } from '@mtcute/core';
+import { UpdateContextDistributed } from '../context/base.js';
+import { UpdateFilter } from './types.js';
+type UpdatesWithText = Message | BusinessMessage | UpdateContextDistributed<InlineQuery | ChosenInlineResult | CallbackQuery | InlineCallbackQuery | BusinessCallbackQuery>;
+/**
+ * Filter objects that match a given regular expression
+ *  - for `Message`, `Message.text` is used
+ *  - for `InlineQuery`, `InlineQuery.query` is used
+ *  - for {@link ChosenInlineResult}, {@link ChosenInlineResult#id} is used
+ *  - for callback queries, `dataStr` is used
+ *
+ * When a regex matches, the match array is stored in a
+ * type-safe extension field `.match` of the object
+ *
+ * @param regex  Regex to be matched
+ */
+export declare function regex(regex: RegExp): UpdateFilter<UpdatesWithText, {
+    match: RegExpMatchArray;
+}>;
+/**
+ * Filter objects which contain the exact text given
+ *  - for `Message`, `Message.text` is used
+ *  - for `InlineQuery`, `InlineQuery.query` is used
+ *  - for {@link ChosenInlineResult}, {@link ChosenInlineResult.id} is used
+ *  - for callback queries, `dataStr` is used
+ *
+ * @param str  String to be matched
+ * @param ignoreCase  Whether string case should be ignored
+ */
+export declare function equals(str: string, ignoreCase?: boolean): UpdateFilter<UpdatesWithText>;
+/**
+ * Filter objects which contain the text given (as a substring)
+ *  - for `Message`, `Message.text` is used
+ *  - for `InlineQuery`, `InlineQuery.query` is used
+ *  - for {@link ChosenInlineResult}, {@link ChosenInlineResult.id} is used
+ *  - for callback queries, `dataStr` is used
+ *
+ * @param str  Substring to be matched
+ * @param ignoreCase  Whether string case should be ignored
+ */
+export declare function contains(str: string, ignoreCase?: boolean): UpdateFilter<UpdatesWithText>;
+/**
+ * Filter objects which contain the text starting with a given string
+ *  - for `Message`, `Message.text` is used
+ *  - for `InlineQuery`, `InlineQuery.query` is used
+ *  - for {@link ChosenInlineResult}, {@link ChosenInlineResult.id} is used
+ *  - for callback queries, `dataStr` is used
+ *
+ * @param str  Substring to be matched
+ * @param ignoreCase  Whether string case should be ignored
+ */
+export declare function startsWith(str: string, ignoreCase?: boolean): UpdateFilter<UpdatesWithText>;
+/**
+ * Filter objects which contain the text ending with a given string
+ *  - for `Message`, `Message.text` is used
+ *  - for `InlineQuery`, `InlineQuery.query` is used
+ *  - for {@link ChosenInlineResult}, {@link ChosenInlineResult.id} is used
+ *  - for callback queries, `dataStr` is used
+ *
+ * @param str  Substring to be matched
+ * @param ignoreCase  Whether string case should be ignored
+ */
+export declare function endsWith(str: string, ignoreCase?: boolean): UpdateFilter<UpdatesWithText>;
+export {};

package/filters/text.d.ts

@@ -1,7 +1,7 @@
-import { BusinessCallbackQuery, BusinessMessage, CallbackQuery, ChosenInlineResult, InlineCallbackQuery, InlineQuery, Message } from '@mtcute/core';
+import { BusinessCallbackQuery, CallbackQuery, ChosenInlineResult, InlineCallbackQuery, InlineQuery, BusinessMessage, Message } from '@mtcute/core';
 import { UpdateContextDistributed } from '../context/base.js';
 import { UpdateFilter } from './types.js';
-type UpdatesWithText = UpdateContextDistributed<Message | BusinessMessage | InlineQuery | ChosenInlineResult | CallbackQuery | InlineCallbackQuery | BusinessCallbackQuery>;
+type UpdatesWithText = Message | BusinessMessage | UpdateContextDistributed<InlineQuery | ChosenInlineResult | CallbackQuery | InlineCallbackQuery | BusinessCallbackQuery>;
 /**
  * Filter objects that match a given regular expression
  *  - for `Message`, `Message.text` is used

package/filters/text.js

@@ -0,0 +1,82 @@
+import { Message, BusinessMessage } from "@mtcute/core";
+function extractText(obj) {
+  if (obj instanceof Message || obj instanceof BusinessMessage) {
+    return obj.text;
+  }
+  switch (obj._name) {
+    case "inline_query":
+      return obj.query;
+    case "chosen_inline_result":
+      return obj.id;
+    case "callback_query":
+    case "inline_callback_query":
+    case "business_callback_query":
+      if (obj.raw.data) return obj.dataStr;
+  }
+  return null;
+}
+function regex(regex2) {
+  return (obj) => {
+    const txt = extractText(obj);
+    if (!txt) return false;
+    const m = txt.match(regex2);
+    if (m) {
+      obj.match = m;
+      return true;
+    }
+    return false;
+  };
+}
+function equals(str, ignoreCase = false) {
+  if (ignoreCase) {
+    str = str.toLowerCase();
+    return (obj) => extractText(obj)?.toLowerCase() === str;
+  }
+  return (obj) => extractText(obj) === str;
+}
+function contains(str, ignoreCase = false) {
+  if (ignoreCase) {
+    str = str.toLowerCase();
+    return (obj) => {
+      const txt = extractText(obj);
+      return txt != null && txt.toLowerCase().includes(str);
+    };
+  }
+  return (obj) => {
+    const txt = extractText(obj);
+    return txt != null && txt.includes(str);
+  };
+}
+function startsWith(str, ignoreCase = false) {
+  if (ignoreCase) {
+    str = str.toLowerCase();
+    return (obj) => {
+      const txt = extractText(obj);
+      return txt != null && txt.toLowerCase().substring(0, str.length) === str;
+    };
+  }
+  return (obj) => {
+    const txt = extractText(obj);
+    return txt != null && txt.substring(0, str.length) === str;
+  };
+}
+function endsWith(str, ignoreCase = false) {
+  if (ignoreCase) {
+    str = str.toLowerCase();
+    return (obj) => {
+      const txt = extractText(obj);
+      return txt != null && txt.toLowerCase().substring(0, str.length) === str;
+    };
+  }
+  return (obj) => {
+    const txt = extractText(obj);
+    return txt != null && txt.substring(0, str.length) === str;
+  };
+}
+export {
+  contains,
+  endsWith,
+  equals,
+  regex,
+  startsWith
+};

package/filters/types.d.cts

@@ -0,0 +1,91 @@
+import { MaybePromise } from '@mtcute/core';
+import { UpdateState } from '../state/update-state.js';
+/**
+ * Type describing a primitive filter, which is a function taking some `Base`
+ * and a {@link TelegramClient}, checking it against some condition
+ * and returning a boolean.
+ *
+ * If `true` is returned, the filter is considered
+ * to be matched, and the appropriate update handler function is called,
+ * otherwise next registered handler is checked.
+ *
+ * Additionally, filter might contain a type modification
+ * to `Base` for better code insights. If it is present,
+ * it is used to overwrite types (!) of some of the `Base` fields
+ * to given (note that this is entirely compile-time! object is not modified)
+ *
+ * For parametrized filters (like {@link filters.regex}),
+ * type modification can also be used to add additional fields
+ * (in case of `regex`, its match array is added to `.match`)
+ *
+ * Example without type mod:
+ * ```typescript
+ *
+ * const hasPhoto: UpdateFilter<Message> = msg => msg.media?.type === 'photo'
+ *
+ * // ..later..
+ * tg.onNewMessage(hasPhoto, async (msg) => {
+ *     // `hasPhoto` filter matched, so we can safely assume
+ *     // that `msg.media` is a Photo.
+ *     //
+ *     // but it is very redundant, verbose and error-rome,
+ *     // wonder if we could make typescript do this automagically and safely...
+ *     await (msg.media as Photo).downloadToFile(`${msg.id}.jpg`)
+ * })
+ * ```
+ *
+ * Example with type mod:
+ * ```typescript
+ *
+ * const hasPhoto: UpdateFilter<Message, { media: Photo }> = msg => msg.media?.type === 'photo'
+ *
+ * // ..later..
+ * tg.onNewMessage(hasPhoto, async (msg) => {
+ *     // since `hasPhoto` filter matched,
+ *     // we have applied the modification to `msg`,
+ *     // and `msg.media` now has type `Photo`
+ *     //
+ *     // no more redundancy and type casts!
+ *     await msg.media.downloadToFile(`${msg.id}.jpg`)
+ * })
+ * ```
+ *
+ * > **Note**: Type modification can contain anything, even totally unrelated types
+ * > and it is *your* task to keep track that everything is correct.
+ * >
+ * > Bad example:
+ * > ```typescript
+ * > // we check for `Photo`, but type contains `Audio`. this will be a problem!
+ * > const hasPhoto: UpdateFilter<Message, { media: Audio }> = msg => msg.media?.type === 'photo'
+ * >
+ * > // ..later..
+ * > tg.onNewMessage(hasPhoto, async (msg) => {
+ * >     // oops! `msg.media` is `Audio` and does not have `.width`!
+ * >     console.log(msg.media.width)
+ * > })
+ * > ```
+ *
+ * > **Warning!** Do not use the generics provided in functions
+ * > like `and`, `or`, etc. Those are meant to be inferred by the compiler!
+ */
+export type UpdateFilter<Base, Mod = {}, State extends object = never> = (update: Base, state?: UpdateState<State>) => MaybePromise<boolean>;
+export type Modify<Base, Mod> = Omit<Base, keyof Mod> & Mod;
+export type Invert<Base, Mod> = {
+    [P in keyof Mod & keyof Base]: Exclude<Base[P], Mod[P]>;
+};
+export type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
+export type ExtractBase<Filter> = Filter extends UpdateFilter<infer I, any> ? I : never;
+export type ExtractMod<Filter> = Filter extends UpdateFilter<any, infer I> ? I : never;
+export type ExtractState<Filter> = Filter extends UpdateFilter<any, any, infer I> ? I : never;
+export type TupleKeys<T extends any[]> = Exclude<keyof T, keyof []>;
+export type WrapBase<T extends any[]> = {
+    [K in TupleKeys<T>]: {
+        base: ExtractBase<T[K]>;
+    };
+};
+export type Values<T> = T[keyof T];
+export type UnwrapBase<T> = T extends {
+    base: any;
+} ? T['base'] : never;
+export type ExtractBaseMany<Filters extends any[]> = UnwrapBase<UnionToIntersection<Values<WrapBase<Filters>>>>;
+export type EmptyObject = Record<never, never>;

package/filters/updates.cjs

@@ -0,0 +1,27 @@
+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 chatMember = (types) => {
+  if (Array.isArray(types)) {
+    const index = {};
+    types.forEach((typ) => index[typ] = true);
+    return (upd) => upd.type in index;
+  }
+  return (upd) => upd.type === types;
+};
+const userStatus = (statuses) => {
+  if (Array.isArray(statuses)) {
+    const index = {};
+    statuses.forEach((typ) => index[typ] = true);
+    return (upd) => upd.status in index;
+  }
+  return (upd) => upd.status === statuses;
+};
+const chatMemberSelf = (upd) => upd.isSelf;
+exports.chatMember = chatMember;
+exports.chatMemberSelf = chatMemberSelf;
+exports.userStatus = userStatus;

package/filters/updates.d.cts

@@ -0,0 +1,39 @@
+import { ChatMemberUpdate, ChatMemberUpdateType, UserStatus, UserStatusUpdate } from '@mtcute/core';
+import { UpdateFilter } from './types.js';
+/**
+ * Create a filter for {@link ChatMemberUpdate} by update type
+ *
+ * @param types  Update type(s)
+ * @link ChatMemberUpdate.Type
+ */
+export declare const chatMember: {
+    <T extends ChatMemberUpdateType>(type: T): UpdateFilter<ChatMemberUpdate, {
+        type: T;
+    }>;
+    <T extends ChatMemberUpdateType[]>(types: T): UpdateFilter<ChatMemberUpdate, {
+        type: T[number];
+    }>;
+};
+/**
+ * Create a filter for {@link UserStatusUpdate} by new user status
+ *
+ * @param statuses  Update type(s)
+ * @link User.Status
+ */
+export declare const userStatus: {
+    <T extends UserStatus>(status: T): UpdateFilter<UserStatusUpdate, {
+        type: T;
+        lastOnline: T extends 'offline' ? Date : null;
+        nextOffline: T extends 'online' ? Date : null;
+    }>;
+    <T extends UserStatus[]>(statuses: T): UpdateFilter<UserStatusUpdate, {
+        type: T[number];
+    }>;
+};
+/**
+ * Create a filter for {@link ChatMemberUpdate} for updates
+ * regarding current user
+ */
+export declare const chatMemberSelf: UpdateFilter<ChatMemberUpdate, {
+    isSelf: true;
+}>;

package/filters/updates.js

@@ -0,0 +1,22 @@
+const chatMember = (types) => {
+  if (Array.isArray(types)) {
+    const index = {};
+    types.forEach((typ) => index[typ] = true);
+    return (upd) => upd.type in index;
+  }
+  return (upd) => upd.type === types;
+};
+const userStatus = (statuses) => {
+  if (Array.isArray(statuses)) {
+    const index = {};
+    statuses.forEach((typ) => index[typ] = true);
+    return (upd) => upd.status in index;
+  }
+  return (upd) => upd.status === statuses;
+};
+const chatMemberSelf = (upd) => upd.isSelf;
+export {
+  chatMember,
+  chatMemberSelf,
+  userStatus
+};

package/filters/user.cjs

@@ -0,0 +1,57 @@
+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 core = require("@mtcute/core");
+const me = (msg) => msg.sender.type === "user" && msg.sender.isSelf || msg.isOutgoing;
+const bot = (msg) => msg.sender.constructor === core.User && msg.sender.isBot;
+const userId = (id) => {
+  const indexId = /* @__PURE__ */ new Set();
+  const indexUsername = /* @__PURE__ */ new Set();
+  let matchSelf = false;
+  if (!Array.isArray(id)) id = [id];
+  id.forEach((id2) => {
+    if (id2 === "me" || id2 === "self") {
+      matchSelf = true;
+    } else if (typeof id2 === "string") {
+      indexUsername.add(id2);
+    } else {
+      indexId.add(id2);
+    }
+  });
+  return (upd) => {
+    switch (upd._name) {
+      case "new_message":
+      case "edit_message":
+      case "new_business_message":
+      case "edit_business_message": {
+        const sender = upd.sender;
+        return matchSelf && sender.type === "user" && sender.isSelf || indexId.has(sender.id) || indexUsername.has(sender.username);
+      }
+      case "user_status":
+      case "user_typing": {
+        const id2 = upd.userId;
+        return matchSelf && id2 === upd.client.storage.self.getCached()?.userId || indexId.has(id2);
+      }
+      case "poll_vote":
+      case "story":
+      case "delete_story": {
+        const peer = upd.peer;
+        if (peer.type !== "user") return false;
+        return matchSelf && peer.isSelf || indexId.has(peer.id) || Boolean(peer.usernames?.some((u) => indexUsername.has(u.username)));
+      }
+      case "history_read": {
+        const id2 = upd.chatId;
+        return matchSelf && id2 === upd.client.storage.self.getCached()?.userId || indexId.has(id2);
+      }
+    }
+    const user = upd.user;
+    return matchSelf && user.isSelf || indexId.has(user.id) || Boolean(user.usernames?.some((u) => indexUsername.has(u.username)));
+  };
+};
+exports.bot = bot;
+exports.me = me;
+exports.userId = userId;

package/filters/user.d.cts

@@ -0,0 +1,24 @@
+import { BotChatJoinRequestUpdate, BusinessCallbackQuery, BusinessMessage, CallbackQuery, ChatMemberUpdate, ChosenInlineResult, DeleteStoryUpdate, HistoryReadUpdate, InlineCallbackQuery, InlineQuery, MaybeArray, Message, PollVoteUpdate, StoryUpdate, UserStatusUpdate, UserTypingUpdate, User } from '@mtcute/core';
+import { UpdateContextDistributed } from '../context/base.js';
+import { UpdateFilter } from './types.js';
+/**
+ * Filter messages generated by yourself (including Saved Messages)
+ */
+export declare const me: UpdateFilter<Message, {
+    sender: User;
+}>;
+/**
+ * Filter messages sent by bots
+ */
+export declare const bot: UpdateFilter<Message, {
+    sender: User;
+}>;
+/**
+ * Filter updates by user ID(s) or username(s)
+ *
+ * Note that only some updates support filtering by username.
+ */
+export declare const userId: {
+    (id: MaybeArray<number>): UpdateFilter<UpdateContextDistributed<Message | BusinessMessage | StoryUpdate | DeleteStoryUpdate | InlineQuery | ChatMemberUpdate | ChosenInlineResult | CallbackQuery | InlineCallbackQuery | BusinessCallbackQuery | PollVoteUpdate | BotChatJoinRequestUpdate>>;
+    (id: MaybeArray<number | string>): UpdateFilter<UpdateContextDistributed<Message | BusinessMessage | UserStatusUpdate | UserTypingUpdate | StoryUpdate | HistoryReadUpdate | DeleteStoryUpdate | InlineQuery | ChatMemberUpdate | ChosenInlineResult | CallbackQuery | InlineCallbackQuery | BusinessCallbackQuery | PollVoteUpdate | BotChatJoinRequestUpdate>>;
+};

package/filters/user.js

@@ -0,0 +1,52 @@
+import { User } from "@mtcute/core";
+const me = (msg) => msg.sender.type === "user" && msg.sender.isSelf || msg.isOutgoing;
+const bot = (msg) => msg.sender.constructor === User && msg.sender.isBot;
+const userId = (id) => {
+  const indexId = /* @__PURE__ */ new Set();
+  const indexUsername = /* @__PURE__ */ new Set();
+  let matchSelf = false;
+  if (!Array.isArray(id)) id = [id];
+  id.forEach((id2) => {
+    if (id2 === "me" || id2 === "self") {
+      matchSelf = true;
+    } else if (typeof id2 === "string") {
+      indexUsername.add(id2);
+    } else {
+      indexId.add(id2);
+    }
+  });
+  return (upd) => {
+    switch (upd._name) {
+      case "new_message":
+      case "edit_message":
+      case "new_business_message":
+      case "edit_business_message": {
+        const sender = upd.sender;
+        return matchSelf && sender.type === "user" && sender.isSelf || indexId.has(sender.id) || indexUsername.has(sender.username);
+      }
+      case "user_status":
+      case "user_typing": {
+        const id2 = upd.userId;
+        return matchSelf && id2 === upd.client.storage.self.getCached()?.userId || indexId.has(id2);
+      }
+      case "poll_vote":
+      case "story":
+      case "delete_story": {
+        const peer = upd.peer;
+        if (peer.type !== "user") return false;
+        return matchSelf && peer.isSelf || indexId.has(peer.id) || Boolean(peer.usernames?.some((u) => indexUsername.has(u.username)));
+      }
+      case "history_read": {
+        const id2 = upd.chatId;
+        return matchSelf && id2 === upd.client.storage.self.getCached()?.userId || indexId.has(id2);
+      }
+    }
+    const user = upd.user;
+    return matchSelf && user.isSelf || indexId.has(user.id) || Boolean(user.usernames?.some((u) => indexUsername.has(u.username)));
+  };
+};
+export {
+  bot,
+  me,
+  userId
+};

package/handler.d.cts

@@ -0,0 +1,41 @@
+import { BotReactionCountUpdate, BotReactionUpdate, BotStoppedUpdate, BusinessConnection, ChatJoinRequestUpdate, ChatMemberUpdate, DeleteBusinessMessageUpdate, DeleteMessageUpdate, DeleteStoryUpdate, HistoryReadUpdate, MaybePromise, PeersIndex, PollUpdate, PollVoteUpdate, StoryUpdate, tl, UserStatusUpdate, UserTypingUpdate } from '@mtcute/core';
+import { TelegramClient } from '@mtcute/core/client.js';
+import { UpdateContext } from './context/base.js';
+import { BusinessCallbackQueryContext, BusinessMessageContext, CallbackQueryContext, ChatJoinRequestUpdateContext, ChosenInlineResultContext, InlineCallbackQueryContext, InlineQueryContext, MessageContext, PreCheckoutQueryContext } from './context/index.js';
+import { PropagationAction } from './propagation.js';
+export interface BaseUpdateHandler<Name, Handler, Checker> {
+    name: Name;
+    callback: Handler;
+    check?: Checker;
+}
+export type ParsedUpdateHandler<Name, Update, State = never> = BaseUpdateHandler<Name, (update: Update, state: State) => MaybePromise<void | PropagationAction>, (update: Update, state: State) => MaybePromise<boolean>>;
+export type RawUpdateHandler = BaseUpdateHandler<'raw', (client: TelegramClient, update: tl.TypeUpdate | tl.TypeMessage, peers: PeersIndex) => MaybePromise<void | PropagationAction>, (client: TelegramClient, update: tl.TypeUpdate | tl.TypeMessage, peers: PeersIndex) => MaybePromise<boolean>>;
+export type NewMessageHandler<T = MessageContext, S = never> = ParsedUpdateHandler<'new_message', T, S>;
+export type EditMessageHandler<T = MessageContext, S = never> = ParsedUpdateHandler<'edit_message', T, S>;
+export type MessageGroupHandler<T = MessageContext, S = never> = ParsedUpdateHandler<'message_group', T, S>;
+export type DeleteMessageHandler<T = UpdateContext<DeleteMessageUpdate>> = ParsedUpdateHandler<'delete_message', T>;
+export type ChatMemberUpdateHandler<T = UpdateContext<ChatMemberUpdate>> = ParsedUpdateHandler<'chat_member', T>;
+export type InlineQueryHandler<T = InlineQueryContext> = ParsedUpdateHandler<'inline_query', T>;
+export type ChosenInlineResultHandler<T = ChosenInlineResultContext> = ParsedUpdateHandler<'chosen_inline_result', T>;
+export type CallbackQueryHandler<T = CallbackQueryContext, S = never> = ParsedUpdateHandler<'callback_query', T, S>;
+export type InlineCallbackQueryHandler<T = InlineCallbackQueryContext, S = never> = ParsedUpdateHandler<'inline_callback_query', T, S>;
+export type BusinessCallbackQueryHandler<T = BusinessCallbackQueryContext, S = never> = ParsedUpdateHandler<'business_callback_query', T, S>;
+export type PollUpdateHandler<T = UpdateContext<PollUpdate>> = ParsedUpdateHandler<'poll', T>;
+export type PollVoteHandler<T = UpdateContext<PollVoteUpdate>> = ParsedUpdateHandler<'poll_vote', T>;
+export type UserStatusUpdateHandler<T = UpdateContext<UserStatusUpdate>> = ParsedUpdateHandler<'user_status', T>;
+export type UserTypingHandler<T = UpdateContext<UserTypingUpdate>> = ParsedUpdateHandler<'user_typing', T>;
+export type HistoryReadHandler<T = UpdateContext<HistoryReadUpdate>> = ParsedUpdateHandler<'history_read', T>;
+export type BotStoppedHandler<T = UpdateContext<BotStoppedUpdate>> = ParsedUpdateHandler<'bot_stopped', T>;
+export type BotChatJoinRequestHandler<T = ChatJoinRequestUpdateContext> = ParsedUpdateHandler<'bot_chat_join_request', T>;
+export type ChatJoinRequestHandler<T = UpdateContext<ChatJoinRequestUpdate>> = ParsedUpdateHandler<'chat_join_request', T>;
+export type PreCheckoutQueryHandler<T = PreCheckoutQueryContext> = ParsedUpdateHandler<'pre_checkout_query', T>;
+export type StoryUpdateHandler<T = UpdateContext<StoryUpdate>> = ParsedUpdateHandler<'story', T>;
+export type DeleteStoryHandler<T = UpdateContext<DeleteStoryUpdate>> = ParsedUpdateHandler<'delete_story', T>;
+export type BotReactionUpdateHandler<T = UpdateContext<BotReactionUpdate>> = ParsedUpdateHandler<'bot_reaction', T>;
+export type BotReactionCountUpdateHandler<T = UpdateContext<BotReactionCountUpdate>> = ParsedUpdateHandler<'bot_reaction_count', T>;
+export type BusinessConnectionUpdateHandler<T = UpdateContext<BusinessConnection>> = ParsedUpdateHandler<'business_connection', T>;
+export type NewBusinessMessageHandler<T = BusinessMessageContext, S = never> = ParsedUpdateHandler<'new_business_message', T, S>;
+export type EditBusinessMessageHandler<T = BusinessMessageContext, S = never> = ParsedUpdateHandler<'edit_business_message', T, S>;
+export type BusinessMessageGroupHandler<T = BusinessMessageContext, S = never> = ParsedUpdateHandler<'business_message_group', T, S>;
+export type DeleteBusinessMessageHandler<T = UpdateContext<DeleteBusinessMessageUpdate>> = ParsedUpdateHandler<'delete_business_message', T>;
+export type UpdateHandler = RawUpdateHandler | NewMessageHandler | EditMessageHandler | MessageGroupHandler | DeleteMessageHandler | ChatMemberUpdateHandler | InlineQueryHandler | ChosenInlineResultHandler | CallbackQueryHandler | InlineCallbackQueryHandler | BusinessCallbackQueryHandler | PollUpdateHandler | PollVoteHandler | UserStatusUpdateHandler | UserTypingHandler | HistoryReadHandler | BotStoppedHandler | BotChatJoinRequestHandler | ChatJoinRequestHandler | PreCheckoutQueryHandler | StoryUpdateHandler | DeleteStoryHandler | BotReactionUpdateHandler | BotReactionCountUpdateHandler | BusinessConnectionUpdateHandler | NewBusinessMessageHandler | EditBusinessMessageHandler | BusinessMessageGroupHandler | DeleteBusinessMessageHandler;