@tgify/tgify 0.1.0

package/src/filters.ts

@@ -0,0 +1,109 @@
+import type {
+  CallbackQuery,
+  CommonMessageBundle,
+  Message,
+  Update,
+} from '@telegraf/types'
+import { DistinctKeys, KeyedDistinct, Guarded } from './core/helpers/util'
+
+export type Filter<U extends Update> = (update: Update) => update is U
+
+export { Guarded }
+
+export type AllGuarded<Fs extends Filter<Update>[]> = Fs extends [
+  infer A,
+  ...infer B,
+]
+  ? B extends []
+    ? Guarded<A>
+    : // TS doesn't know otherwise that B is Filter[]
+    B extends Filter<Update>[]
+    ? Guarded<A> & AllGuarded<B>
+    : never
+  : never
+
+export const message =
+  <Ks extends DistinctKeys<Message>[]>(...keys: Ks) =>
+  (
+    update: Update
+  ): update is Update.MessageUpdate<KeyedDistinct<Message, Ks[number]>> => {
+    if (!('message' in update)) return false
+    for (const key of keys) {
+      if (!(key in update.message)) return false
+    }
+    return true
+  }
+
+export const editedMessage =
+  <Ks extends DistinctKeys<CommonMessageBundle>[]>(...keys: Ks) =>
+  (
+    update: Update
+  ): update is Update.EditedMessageUpdate<
+    KeyedDistinct<CommonMessageBundle, Ks[number]>
+  > => {
+    if (!('edited_message' in update)) return false
+    for (const key of keys) {
+      if (!(key in update.edited_message)) return false
+    }
+    return true
+  }
+
+export const channelPost =
+  <Ks extends DistinctKeys<Message>[]>(...keys: Ks) =>
+  (
+    update: Update
+  ): update is Update.ChannelPostUpdate<KeyedDistinct<Message, Ks[number]>> => {
+    if (!('channel_post' in update)) return false
+    for (const key of keys) {
+      if (!(key in update.channel_post)) return false
+    }
+    return true
+  }
+
+export const editedChannelPost =
+  <Ks extends DistinctKeys<CommonMessageBundle>[]>(...keys: Ks) =>
+  (
+    update: Update
+  ): update is Update.EditedChannelPostUpdate<
+    KeyedDistinct<CommonMessageBundle, Ks[number]>
+  > => {
+    if (!('edited_channel_post' in update)) return false
+    for (const key of keys) {
+      if (!(key in update.edited_channel_post)) return false
+    }
+    return true
+  }
+
+export const callbackQuery =
+  <Ks extends DistinctKeys<CallbackQuery>[]>(...keys: Ks) =>
+  (
+    update: Update
+  ): update is Update.CallbackQueryUpdate<
+    KeyedDistinct<CallbackQuery, Ks[number]>
+  > => {
+    if (!('callback_query' in update)) return false
+    for (const key of keys) {
+      if (!(key in update.callback_query)) return false
+    }
+    return true
+  }
+
+/** Any of the provided filters must match */
+export const anyOf =
+  <Us extends Update[]>(
+    ...filters: {
+      [UIdx in keyof Us]: Filter<Us[UIdx]>
+    }
+  ) =>
+  (update: Update): update is Us[number] => {
+    for (const filter of filters) if (filter(update)) return true
+    return false
+  }
+
+/** All of the provided filters must match */
+export const allOf =
+  <U extends Update, Fs extends Filter<U>[]>(...filters: Fs) =>
+  (update: Update): update is AllGuarded<Fs> => {
+    for (const filter of filters) if (!filter(update)) return false
+    return true
+  }

package/src/format.ts

@@ -0,0 +1,110 @@
+import { User } from '@telegraf/types'
+import {
+  FmtString,
+  createFmt,
+  linkOrMention,
+  join as _join,
+} from './core/helpers/formatting'
+
+export { FmtString }
+
+type Nestable<Kind extends string> = string | number | boolean | FmtString<Kind>
+type Nesting<Kind extends string> = [
+  parts: Nestable<Kind> | readonly Nestable<Kind>[],
+  ...items: Nestable<Kind>[],
+]
+type Nests<Is extends string, Kind extends string> = (
+  ...args: Nesting<Kind>
+) => FmtString<Is>
+
+// Nests<A, B> means the function will return A, and it can nest B
+// Nests<'fmt', string> means it will nest anything
+// Nests<'code', never> means it will not nest anything
+
+// Allowing everything to nest 'fmt' is a necessary evil; it allows to indirectly nest illegal entities
+// Except for 'code' and 'pre', which don't nest anything anyway, so they only deal with strings
+
+export const join = _join as Nests<'fmt', string>
+
+export const fmt = createFmt() as Nests<'fmt', string>
+
+export const bold = createFmt('bold') as Nests<
+  'bold',
+  'fmt' | 'bold' | 'italic' | 'underline' | 'strikethrough' | 'spoiler'
+>
+
+export const italic = createFmt('italic') as Nests<
+  'italic',
+  'fmt' | 'bold' | 'italic' | 'underline' | 'strikethrough' | 'spoiler'
+>
+
+export const spoiler = createFmt('spoiler') as Nests<
+  'spoiler',
+  'fmt' | 'bold' | 'italic' | 'underline' | 'strikethrough' | 'spoiler'
+>
+
+export const strikethrough =
+  //
+  createFmt('strikethrough') as Nests<
+    'strikethrough',
+    'fmt' | 'bold' | 'italic' | 'underline' | 'strikethrough' | 'spoiler'
+  >
+
+export const underline =
+  //
+  createFmt('underline') as Nests<
+    'underline',
+    'fmt' | 'bold' | 'italic' | 'underline' | 'strikethrough' | 'spoiler'
+  >
+
+export const quote =
+  //
+  createFmt('blockquote') as Nests<
+    'blockquote',
+    | 'fmt'
+    | 'bold'
+    | 'italic'
+    | 'underline'
+    | 'strikethrough'
+    | 'spoiler'
+    | 'code'
+  >
+
+export const code = createFmt('code') as Nests<'code', never>
+
+export const pre = (language: string) =>
+  createFmt('pre', { language }) as Nests<'pre', never>
+
+export const link = (
+  content: Nestable<
+    | 'fmt'
+    | 'bold'
+    | 'italic'
+    | 'underline'
+    | 'strikethrough'
+    | 'spoiler'
+    | 'code'
+  >,
+  url: string
+) =>
+  //
+  linkOrMention(content, { type: 'text_link', url }) as FmtString<'text_link'>
+
+export const mention = (
+  name: Nestable<
+    | 'fmt'
+    | 'bold'
+    | 'italic'
+    | 'underline'
+    | 'strikethrough'
+    | 'spoiler'
+    | 'code'
+  >,
+  user: number | User
+) =>
+  typeof user === 'number'
+    ? link(name, 'tg://user?id=' + user)
+    : (linkOrMention(name, {
+        type: 'text_mention',
+        user,
+      }) as FmtString<'text_mention'>)

package/src/future.ts

@@ -0,0 +1,213 @@
+import { ReplyParameters } from '@telegraf/types'
+import Context from './context'
+import { Middleware } from './middleware'
+
+type ReplyContext = { [key in keyof Context & `reply${string}`]: Context[key] }
+
+function makeReply<
+  C extends Context,
+  E extends { reply_parameters?: ReplyParameters },
+>(ctx: C, extra?: E) {
+  if (ctx.msgId)
+    return {
+      // overrides in this order so user can override all properties
+      reply_parameters: {
+        message_id: ctx.msgId,
+        ...extra?.reply_parameters,
+      },
+      ...extra,
+    }
+  else return extra
+}
+
+const replyContext: ReplyContext = {
+  replyWithChatAction: function () {
+    throw new TypeError(
+      'ctx.replyWithChatAction has been removed, use ctx.sendChatAction instead'
+    )
+  },
+  reply(this: Context, text, extra) {
+    this.assert(this.chat, 'reply')
+    return this.telegram.sendMessage(this.chat.id, text, makeReply(this, extra))
+  },
+  replyWithAnimation(this: Context, animation, extra) {
+    this.assert(this.chat, 'replyWithAnimation')
+    return this.telegram.sendAnimation(
+      this.chat.id,
+      animation,
+      makeReply(this, extra)
+    )
+  },
+  replyWithAudio(this: Context, audio, extra) {
+    this.assert(this.chat, 'replyWithAudio')
+    return this.telegram.sendAudio(this.chat.id, audio, makeReply(this, extra))
+  },
+  replyWithContact(this: Context, phoneNumber, firstName, extra) {
+    this.assert(this.chat, 'replyWithContact')
+    return this.telegram.sendContact(
+      this.chat.id,
+      phoneNumber,
+      firstName,
+      makeReply(this, extra)
+    )
+  },
+  replyWithDice(this: Context, extra) {
+    this.assert(this.chat, 'replyWithDice')
+    return this.telegram.sendDice(this.chat.id, makeReply(this, extra))
+  },
+  replyWithDocument(this: Context, document, extra) {
+    this.assert(this.chat, 'replyWithDocument')
+    return this.telegram.sendDocument(
+      this.chat.id,
+      document,
+      makeReply(this, extra)
+    )
+  },
+  replyWithGame(this: Context, gameName, extra) {
+    this.assert(this.chat, 'replyWithGame')
+    return this.telegram.sendGame(
+      this.chat.id,
+      gameName,
+      makeReply(this, extra)
+    )
+  },
+  replyWithHTML(this: Context, html, extra) {
+    this.assert(this.chat, 'replyWithHTML')
+    return this.telegram.sendMessage(this.chat.id, html, {
+      parse_mode: 'HTML',
+      ...makeReply(this, extra),
+    })
+  },
+  replyWithInvoice(this: Context, invoice, extra) {
+    this.assert(this.chat, 'replyWithInvoice')
+    return this.telegram.sendInvoice(
+      this.chat.id,
+      invoice,
+      makeReply(this, extra)
+    )
+  },
+  replyWithLocation(this: Context, latitude, longitude, extra) {
+    this.assert(this.chat, 'replyWithLocation')
+    return this.telegram.sendLocation(
+      this.chat.id,
+      latitude,
+      longitude,
+      makeReply(this, extra)
+    )
+  },
+  replyWithMarkdown(this: Context, markdown, extra) {
+    this.assert(this.chat, 'replyWithMarkdown')
+    return this.telegram.sendMessage(this.chat.id, markdown, {
+      parse_mode: 'Markdown',
+      ...makeReply(this, extra),
+    })
+  },
+  replyWithMarkdownV2(this: Context, markdown, extra) {
+    this.assert(this.chat, 'replyWithMarkdownV2')
+    return this.telegram.sendMessage(this.chat.id, markdown, {
+      parse_mode: 'MarkdownV2',
+      ...makeReply(this, extra),
+    })
+  },
+  replyWithMediaGroup(this: Context, media, extra) {
+    this.assert(this.chat, 'replyWithMediaGroup')
+    return this.telegram.sendMediaGroup(
+      this.chat.id,
+      media,
+      makeReply(this, extra)
+    )
+  },
+  replyWithPhoto(this: Context, photo, extra) {
+    this.assert(this.chat, 'replyWithPhoto')
+    return this.telegram.sendPhoto(this.chat.id, photo, makeReply(this, extra))
+  },
+  replyWithPoll(this: Context, question, options, extra) {
+    this.assert(this.chat, 'replyWithPoll')
+    return this.telegram.sendPoll(
+      this.chat.id,
+      question,
+      options,
+      makeReply(this, extra)
+    )
+  },
+  replyWithQuiz(this: Context, question, options, extra) {
+    this.assert(this.chat, 'replyWithQuiz')
+    return this.telegram.sendQuiz(
+      this.chat.id,
+      question,
+      options,
+      makeReply(this, extra)
+    )
+  },
+  replyWithSticker(this: Context, sticker, extra) {
+    this.assert(this.chat, 'replyWithSticker')
+    return this.telegram.sendSticker(
+      this.chat.id,
+      sticker,
+      makeReply(this, extra)
+    )
+  },
+  replyWithVenue(this: Context, latitude, longitude, title, address, extra) {
+    this.assert(this.chat, 'replyWithVenue')
+    return this.telegram.sendVenue(
+      this.chat.id,
+      latitude,
+      longitude,
+      title,
+      address,
+      makeReply(this, extra)
+    )
+  },
+  replyWithVideo(this: Context, video, extra) {
+    this.assert(this.chat, 'replyWithVideo')
+    return this.telegram.sendVideo(this.chat.id, video, makeReply(this, extra))
+  },
+  replyWithVideoNote(this: Context, videoNote, extra) {
+    this.assert(this.chat, 'replyWithVideoNote')
+    return this.telegram.sendVideoNote(
+      this.chat.id,
+      videoNote,
+      makeReply(this, extra)
+    )
+  },
+  replyWithVoice(this: Context, voice, extra) {
+    this.assert(this.chat, 'replyWithVoice')
+    return this.telegram.sendVoice(this.chat.id, voice, makeReply(this, extra))
+  },
+}
+
+/**
+ * Sets up Context to use the new reply methods.
+ * This middleware makes `ctx.reply()` and `ctx.replyWith*()` methods will actually reply to the message they are replying to.
+ * Use `ctx.sendMessage()` to send a message in chat without replying to it.
+ *
+ * If the message to reply is deleted, `reply()` will send a normal message.
+ * If the update is not a message and we are unable to reply, `reply()` will send a normal message.
+ */
+export function useNewReplies<C extends Context>(): Middleware<C> {
+  return (ctx, next) => {
+    ctx.reply = replyContext.reply
+    ctx.replyWithPhoto = replyContext.replyWithPhoto
+    ctx.replyWithMediaGroup = replyContext.replyWithMediaGroup
+    ctx.replyWithAudio = replyContext.replyWithAudio
+    ctx.replyWithDice = replyContext.replyWithDice
+    ctx.replyWithDocument = replyContext.replyWithDocument
+    ctx.replyWithSticker = replyContext.replyWithSticker
+    ctx.replyWithVideo = replyContext.replyWithVideo
+    ctx.replyWithAnimation = replyContext.replyWithAnimation
+    ctx.replyWithVideoNote = replyContext.replyWithVideoNote
+    ctx.replyWithInvoice = replyContext.replyWithInvoice
+    ctx.replyWithGame = replyContext.replyWithGame
+    ctx.replyWithVoice = replyContext.replyWithVoice
+    ctx.replyWithPoll = replyContext.replyWithPoll
+    ctx.replyWithQuiz = replyContext.replyWithQuiz
+    ctx.replyWithChatAction = replyContext.replyWithChatAction
+    ctx.replyWithLocation = replyContext.replyWithLocation
+    ctx.replyWithVenue = replyContext.replyWithVenue
+    ctx.replyWithContact = replyContext.replyWithContact
+    ctx.replyWithMarkdown = replyContext.replyWithMarkdown
+    ctx.replyWithMarkdownV2 = replyContext.replyWithMarkdownV2
+    ctx.replyWithHTML = replyContext.replyWithHTML
+    return next()
+  }
+}

package/src/index.ts

@@ -0,0 +1,17 @@
+export { Telegraf } from './telegraf'
+export { Context, NarrowedContext } from './context'
+export { Composer } from './composer'
+export { Middleware, MiddlewareFn, MiddlewareObj } from './middleware'
+export { Router } from './router'
+export { TelegramError } from './core/network/error'
+export { Telegram } from './telegram'
+
+export * as Types from './telegram-types'
+export * as Markup from './markup'
+export * as Input from './input'
+export * as Format from './format'
+
+export { deunionize } from './core/helpers/deunionize'
+export { session, MemorySessionStore, SessionStore } from './session'
+
+export * as Scenes from './scenes'

package/src/input.ts

@@ -0,0 +1,59 @@
+import { InputFile } from './core/types/typegram'
+
+/**
+ * The local file specified by path will be uploaded to Telegram using multipart/form-data.
+ *
+ * 10 MB max size for photos, 50 MB for other files.
+ */
+// prettier-ignore
+export const fromLocalFile = (path: string, filename?: string): InputFile => ({ source: path, filename })
+
+/**
+ * The buffer will be uploaded as file to Telegram using multipart/form-data.
+ *
+ * 10 MB max size for photos, 50 MB for other files.
+ */
+// prettier-ignore
+export const fromBuffer = (buffer: Buffer, filename?: string): InputFile => ({ source: buffer, filename })
+
+/**
+ * Contents of the stream will be uploaded as file to Telegram using multipart/form-data.
+ *
+ * 10 MB max size for photos, 50 MB for other files.
+ */
+// prettier-ignore
+export const fromReadableStream = (stream: NodeJS.ReadableStream, filename?: string): InputFile => ({ source: stream, filename })
+
+/**
+ * Contents of the URL will be streamed to Telegram.
+ *
+ * 10 MB max size for photos, 50 MB for other files.
+ */
+// prettier-ignore
+export const fromURLStream = (url: string | URL, filename?: string): InputFile => ({ url: url.toString(), filename })
+
+/**
+ * Provide Telegram with an HTTP URL for the file to be sent.
+ * Telegram will download and send the file.
+ *
+ * * The target file must have the correct MIME type (e.g., audio/mpeg for `sendAudio`, etc.).
+ * * `sendDocument` with URL will currently only work for GIF, PDF and ZIP files.
+ * * To use `sendVoice`, the file must have the type audio/ogg and be no more than 1MB in size.
+ * 1-20MB voice notes will be sent as files.
+ *
+ * 5 MB max size for photos and 20 MB max for other types of content.
+ */
+export const fromURL = (url: string | URL): string => url.toString()
+
+/**
+ * If the file is already stored somewhere on the Telegram servers, you don't need to reupload it:
+ * each file object has a file_id field, simply pass this file_id as a parameter instead of uploading.
+ *
+ * It is not possible to change the file type when resending by file_id.
+ *
+ * It is not possible to resend thumbnails using file_id.
+ * They have to be uploaded using one of the other Input methods.
+ *
+ * There are no limits for files sent this way.
+ */
+export const fromFileId = (fileId: string): string => fileId

package/src/markup.ts

@@ -0,0 +1,142 @@
+import {
+  ForceReply,
+  InlineKeyboardButton,
+  InlineKeyboardMarkup,
+  KeyboardButton,
+  ReplyKeyboardMarkup,
+  ReplyKeyboardRemove,
+} from './core/types/typegram'
+import { is2D } from './core/helpers/check'
+
+type Hideable<B> = B & { hide?: boolean }
+type HideableKBtn = Hideable<KeyboardButton>
+type HideableIKBtn = Hideable<InlineKeyboardButton>
+
+export class Markup<
+  T extends
+    | InlineKeyboardMarkup
+    | ReplyKeyboardMarkup
+    | ReplyKeyboardRemove
+    | ForceReply,
+> {
+  constructor(readonly reply_markup: T) {}
+
+  selective<T extends ForceReply | ReplyKeyboardMarkup>(
+    this: Markup<T>,
+    value = true
+  ) {
+    return new Markup<T>({ ...this.reply_markup, selective: value })
+  }
+
+  placeholder<T extends ForceReply | ReplyKeyboardMarkup>(
+    this: Markup<T>,
+    placeholder: string
+  ) {
+    return new Markup<T>({
+      ...this.reply_markup,
+      input_field_placeholder: placeholder,
+    })
+  }
+
+  resize(this: Markup<ReplyKeyboardMarkup>, value = true) {
+    return new Markup<ReplyKeyboardMarkup>({
+      ...this.reply_markup,
+      resize_keyboard: value,
+    })
+  }
+
+  oneTime(this: Markup<ReplyKeyboardMarkup>, value = true) {
+    return new Markup<ReplyKeyboardMarkup>({
+      ...this.reply_markup,
+      one_time_keyboard: value,
+    })
+  }
+
+  persistent(this: Markup<ReplyKeyboardMarkup>, value = true) {
+    return new Markup<ReplyKeyboardMarkup>({
+      ...this.reply_markup,
+      is_persistent: value,
+    })
+  }
+}
+
+export * as button from './button'
+
+export function removeKeyboard(): Markup<ReplyKeyboardRemove> {
+  return new Markup<ReplyKeyboardRemove>({ remove_keyboard: true })
+}
+
+export function forceReply(): Markup<ForceReply> {
+  return new Markup<ForceReply>({ force_reply: true })
+}
+
+export function keyboard(buttons: HideableKBtn[][]): Markup<ReplyKeyboardMarkup>
+export function keyboard(
+  buttons: HideableKBtn[],
+  options?: Partial<KeyboardBuildingOptions<HideableKBtn>>
+): Markup<ReplyKeyboardMarkup>
+export function keyboard(
+  buttons: HideableKBtn[] | HideableKBtn[][],
+  options?: Partial<KeyboardBuildingOptions<HideableKBtn>>
+): Markup<ReplyKeyboardMarkup> {
+  const keyboard = buildKeyboard(buttons, {
+    columns: 1,
+    ...options,
+  })
+  return new Markup<ReplyKeyboardMarkup>({ keyboard })
+}
+
+export function inlineKeyboard(
+  buttons: HideableIKBtn[][]
+): Markup<InlineKeyboardMarkup>
+export function inlineKeyboard(
+  buttons: HideableIKBtn[],
+  options?: Partial<KeyboardBuildingOptions<HideableIKBtn>>
+): Markup<InlineKeyboardMarkup>
+export function inlineKeyboard(
+  buttons: HideableIKBtn[] | HideableIKBtn[][],
+  options?: Partial<KeyboardBuildingOptions<HideableIKBtn>>
+): Markup<InlineKeyboardMarkup> {
+  const inlineKeyboard = buildKeyboard(buttons, {
+    columns: buttons.length,
+    ...options,
+  })
+  return new Markup<InlineKeyboardMarkup>({ inline_keyboard: inlineKeyboard })
+}
+
+interface KeyboardBuildingOptions<B extends HideableKBtn | HideableIKBtn> {
+  wrap?: (btn: B, index: number, currentRow: B[]) => boolean
+  columns: number
+}
+
+function buildKeyboard<B extends HideableKBtn | HideableIKBtn>(
+  buttons: B[] | B[][],
+  options: KeyboardBuildingOptions<B>
+): B[][] {
+  const result: B[][] = []
+  if (!Array.isArray(buttons)) {
+    return result
+  }
+  if (is2D(buttons)) {
+    return buttons.map((row) => row.filter((button) => !button.hide))
+  }
+  const wrapFn =
+    options.wrap !== undefined
+      ? options.wrap
+      : (_btn: B, _index: number, currentRow: B[]) =>
+          currentRow.length >= options.columns
+  let currentRow: B[] = []
+  let index = 0
+  for (const btn of buttons.filter((button) => !button.hide)) {
+    if (wrapFn(btn, index, currentRow) && currentRow.length > 0) {
+      result.push(currentRow)
+      currentRow = []
+    }
+    currentRow.push(btn)
+    index++
+  }
+  if (currentRow.length > 0) {
+    result.push(currentRow)
+  }
+  return result
+}

package/src/middleware.ts

@@ -0,0 +1,24 @@
+import { Context } from './context'
+import { Update } from './core/types/typegram'
+
+/*
+  next's parameter is in a contravariant position, and thus, trying to type it
+  prevents assigning `MiddlewareFn<ContextMessageUpdate>`
+  to `MiddlewareFn<CustomContext>`.
+  Middleware passing the parameter should be a separate type instead.
+*/
+export type MiddlewareFn<C extends Context<U>, U extends Update = Update> = (
+  ctx: C,
+  next: () => Promise<void>
+) => Promise<unknown> | void
+
+export interface MiddlewareObj<
+  C extends Context<U>,
+  U extends Update = Update,
+> {
+  middleware: () => MiddlewareFn<C, U>
+}
+
+export type Middleware<C extends Context<U>, U extends Update = Update> =
+  | MiddlewareFn<C, U>
+  | MiddlewareObj<C, U>