@tgify/tgify 0.1.0 → 0.1.4

package/src/markup.ts

@@ -1,142 +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
-}
+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

@@ -1,24 +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>
+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>

package/src/reactions.ts

@@ -1,118 +1,118 @@
-import { Deunionize } from './core/helpers/deunionize'
-import { indexed } from './core/helpers/util'
-import * as tg from './core/types/typegram'
-
-export type Digit = '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9'
-export const Digit = new Set(['0', '1', '2', '3', '4', '5', '6', '7', '8', '9'])
-export type Reaction =
-  | tg.TelegramEmoji
-  | `${Digit}${string}`
-  | Deunionize<tg.ReactionType>
-
-type ReactionCtx = { update: Partial<tg.Update.MessageReactionUpdate> }
-
-const inspectReaction = (reaction: tg.ReactionType) => {
-  if (reaction.type === 'custom_emoji')
-    return `Custom(${reaction.custom_emoji_id})`
-  else return reaction.emoji
-}
-
-export class ReactionList {
-  // this is a lie, proxy will be used to access the properties
-  [index: number]: Deunionize<tg.ReactionType>
-
-  protected constructor(protected list: tg.ReactionType[]) {}
-
-  static fromArray(list: tg.ReactionType[] = []): ReactionList {
-    return indexed(
-      new ReactionList(list),
-      function (this: ReactionList, index) {
-        return this.list[index]
-      }
-    )
-  }
-
-  static has(reactions: tg.ReactionType[], reaction: Reaction): boolean {
-    if (typeof reaction === 'string')
-      if (Digit.has(reaction[0] as string))
-        return reactions.some(
-          (r: Deunionize<tg.ReactionType>) => r.custom_emoji_id === reaction
-        )
-      else
-        return reactions.some(
-          (r: Deunionize<tg.ReactionType>) => r.emoji === reaction
-        )
-
-    return reactions.some((r: Deunionize<tg.ReactionType>) => {
-      if (r.type === 'custom_emoji')
-        return r.custom_emoji_id === reaction.custom_emoji_id
-      else if (r.type === 'emoji') return r.emoji === reaction.emoji
-    })
-  }
-
-  toArray(): tg.ReactionType[] {
-    return [...this.list]
-  }
-
-  filter(
-    filterFn: (value: tg.ReactionType, index: number) => boolean
-  ): ReactionList {
-    return ReactionList.fromArray(this.list.filter(filterFn))
-  }
-
-  has(reaction: Reaction): boolean {
-    return ReactionList.has(this.list, reaction)
-  }
-
-  get count(): number {
-    return this.list.length
-  }
-
-  [Symbol.iterator]() {
-    return this.list[Symbol.iterator]()
-  }
-
-  [Symbol.for('nodejs.util.inspect.custom')]() {
-    const flattened = this.list.map(inspectReaction).join(', ')
-    return ['ReactionList {', flattened, '}'].join(' ')
-  }
-}
-
-export class MessageReactions extends ReactionList {
-  private constructor(public ctx: ReactionCtx) {
-    super(ctx.update.message_reaction?.new_reaction ?? [])
-  }
-
-  static from(ctx: ReactionCtx) {
-    return indexed(
-      new MessageReactions(ctx),
-      function (this: MessageReactions, index) {
-        return this.list[index]
-      }
-    )
-  }
-
-  get old() {
-    return ReactionList.fromArray(
-      this.ctx.update.message_reaction?.old_reaction
-    )
-  }
-
-  get new() {
-    return ReactionList.fromArray(
-      this.ctx.update.message_reaction?.new_reaction
-    )
-  }
-
-  get added(): ReactionList {
-    return this.new.filter((reaction) => !this.old.has(reaction))
-  }
-
-  get removed(): ReactionList {
-    return this.old.filter((reaction) => !this.new.has(reaction))
-  }
-
-  get kept(): ReactionList {
-    return this.new.filter((reaction) => this.old.has(reaction))
-  }
-}
+import { Deunionize } from './core/helpers/deunionize'
+import { indexed } from './core/helpers/util'
+import * as tg from './core/types/typegram'
+
+export type Digit = '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9'
+export const Digit = new Set(['0', '1', '2', '3', '4', '5', '6', '7', '8', '9'])
+export type Reaction =
+  | tg.TelegramEmoji
+  | `${Digit}${string}`
+  | Deunionize<tg.ReactionType>
+
+type ReactionCtx = { update: Partial<tg.Update.MessageReactionUpdate> }
+
+const inspectReaction = (reaction: tg.ReactionType) => {
+  if (reaction.type === 'custom_emoji')
+    return `Custom(${reaction.custom_emoji_id})`
+  else return reaction.emoji
+}
+
+export class ReactionList {
+  // this is a lie, proxy will be used to access the properties
+  [index: number]: Deunionize<tg.ReactionType>
+
+  protected constructor(protected list: tg.ReactionType[]) {}
+
+  static fromArray(list: tg.ReactionType[] = []): ReactionList {
+    return indexed(
+      new ReactionList(list),
+      function (this: ReactionList, index) {
+        return this.list[index]
+      }
+    )
+  }
+
+  static has(reactions: tg.ReactionType[], reaction: Reaction): boolean {
+    if (typeof reaction === 'string')
+      if (Digit.has(reaction[0] as string))
+        return reactions.some(
+          (r: Deunionize<tg.ReactionType>) => r.custom_emoji_id === reaction
+        )
+      else
+        return reactions.some(
+          (r: Deunionize<tg.ReactionType>) => r.emoji === reaction
+        )
+
+    return reactions.some((r: Deunionize<tg.ReactionType>) => {
+      if (r.type === 'custom_emoji')
+        return r.custom_emoji_id === reaction.custom_emoji_id
+      else if (r.type === 'emoji') return r.emoji === reaction.emoji
+    })
+  }
+
+  toArray(): tg.ReactionType[] {
+    return [...this.list]
+  }
+
+  filter(
+    filterFn: (value: tg.ReactionType, index: number) => boolean
+  ): ReactionList {
+    return ReactionList.fromArray(this.list.filter(filterFn))
+  }
+
+  has(reaction: Reaction): boolean {
+    return ReactionList.has(this.list, reaction)
+  }
+
+  get count(): number {
+    return this.list.length
+  }
+
+  [Symbol.iterator]() {
+    return this.list[Symbol.iterator]()
+  }
+
+  [Symbol.for('nodejs.util.inspect.custom')]() {
+    const flattened = this.list.map(inspectReaction).join(', ')
+    return ['ReactionList {', flattened, '}'].join(' ')
+  }
+}
+
+export class MessageReactions extends ReactionList {
+  private constructor(public ctx: ReactionCtx) {
+    super(ctx.update.message_reaction?.new_reaction ?? [])
+  }
+
+  static from(ctx: ReactionCtx) {
+    return indexed(
+      new MessageReactions(ctx),
+      function (this: MessageReactions, index) {
+        return this.list[index]
+      }
+    )
+  }
+
+  get old() {
+    return ReactionList.fromArray(
+      this.ctx.update.message_reaction?.old_reaction
+    )
+  }
+
+  get new() {
+    return ReactionList.fromArray(
+      this.ctx.update.message_reaction?.new_reaction
+    )
+  }
+
+  get added(): ReactionList {
+    return this.new.filter((reaction) => !this.old.has(reaction))
+  }
+
+  get removed(): ReactionList {
+    return this.old.filter((reaction) => !this.new.has(reaction))
+  }
+
+  get kept(): ReactionList {
+    return this.new.filter((reaction) => this.old.has(reaction))
+  }
+}

package/src/router.ts

@@ -1,55 +1,55 @@
-/** @format */
-
-import { Middleware, MiddlewareObj } from './middleware'
-import Composer from './composer'
-import Context from './context'
-
-type NonemptyReadonlyArray<T> = readonly [T, ...T[]]
-
-type RouteFn<TContext extends Context> = (ctx: TContext) => {
-  route: string
-  context?: Partial<TContext>
-  state?: Partial<TContext['state']>
-} | null
-
-/** @deprecated in favor of {@link Composer.dispatch} */
-export class Router<C extends Context> implements MiddlewareObj<C> {
-  private otherwiseHandler: Middleware<C> = Composer.passThru()
-
-  constructor(
-    private readonly routeFn: RouteFn<C>,
-    public handlers = new Map<string, Middleware<C>>()
-  ) {
-    if (typeof routeFn !== 'function') {
-      throw new Error('Missing routing function')
-    }
-  }
-
-  on(route: string, ...fns: NonemptyReadonlyArray<Middleware<C>>) {
-    if (fns.length === 0) {
-      throw new TypeError('At least one handler must be provided')
-    }
-    this.handlers.set(route, Composer.compose(fns))
-    return this
-  }
-
-  otherwise(...fns: NonemptyReadonlyArray<Middleware<C>>) {
-    if (fns.length === 0) {
-      throw new TypeError('At least one otherwise handler must be provided')
-    }
-    this.otherwiseHandler = Composer.compose(fns)
-    return this
-  }
-
-  middleware() {
-    return Composer.lazy<C>((ctx) => {
-      const result = this.routeFn(ctx)
-      if (result == null) {
-        return this.otherwiseHandler
-      }
-      Object.assign(ctx, result.context)
-      Object.assign(ctx.state, result.state)
-      return this.handlers.get(result.route) ?? this.otherwiseHandler
-    })
-  }
-}
+/** @format */
+
+import { Middleware, MiddlewareObj } from './middleware'
+import Composer from './composer'
+import Context from './context'
+
+type NonemptyReadonlyArray<T> = readonly [T, ...T[]]
+
+type RouteFn<TContext extends Context> = (ctx: TContext) => {
+  route: string
+  context?: Partial<TContext>
+  state?: Partial<TContext['state']>
+} | null
+
+/** @deprecated in favor of {@link Composer.dispatch} */
+export class Router<C extends Context> implements MiddlewareObj<C> {
+  private otherwiseHandler: Middleware<C> = Composer.passThru()
+
+  constructor(
+    private readonly routeFn: RouteFn<C>,
+    public handlers = new Map<string, Middleware<C>>()
+  ) {
+    if (typeof routeFn !== 'function') {
+      throw new Error('Missing routing function')
+    }
+  }
+
+  on(route: string, ...fns: NonemptyReadonlyArray<Middleware<C>>) {
+    if (fns.length === 0) {
+      throw new TypeError('At least one handler must be provided')
+    }
+    this.handlers.set(route, Composer.compose(fns))
+    return this
+  }
+
+  otherwise(...fns: NonemptyReadonlyArray<Middleware<C>>) {
+    if (fns.length === 0) {
+      throw new TypeError('At least one otherwise handler must be provided')
+    }
+    this.otherwiseHandler = Composer.compose(fns)
+    return this
+  }
+
+  middleware() {
+    return Composer.lazy<C>((ctx) => {
+      const result = this.routeFn(ctx)
+      if (result == null) {
+        return this.otherwiseHandler
+      }
+      Object.assign(ctx, result.context)
+      Object.assign(ctx.state, result.state)
+      return this.handlers.get(result.route) ?? this.otherwiseHandler
+    })
+  }
+}