teledzik 1.0.0

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>

package/src/paginated.ts

@@ -0,0 +1,75 @@
+import * as Markup from './markup'
+
+export interface PaginationOptions<T> {
+  page?: number
+  pageSize?: number
+  callbackPrefix?: string
+  formatItem?: (item: T, index: number) => string
+  buttonText?: (item: T) => string
+  buttonData?: (item: T) => string
+}
+
+export interface PaginatedResult<T> {
+  items: T[]
+  page: number
+  totalPages: number
+  totalItems: number
+  text: string
+  keyboard: ReturnType<typeof Markup.inlineKeyboard>
+}
+
+export class PaginatedBuilder {
+  static create<T>(items: T[], options: PaginationOptions<T> = {}): PaginatedResult<T> {
+    const page = options.page ?? 1
+    const pageSize = options.pageSize ?? 5
+    const prefix = options.callbackPrefix ?? 'page'
+    const totalItems = items.length
+    const totalPages = Math.max(1, Math.ceil(totalItems / pageSize))
+    const currentPage = Math.min(Math.max(1, page), totalPages)
+
+    const startIndex = (currentPage - 1) * pageSize
+    const pageItems = items.slice(startIndex, startIndex + pageSize)
+
+    let text = ''
+    if (options.formatItem) {
+      text = pageItems.map((item, idx) => options.formatItem!(item, startIndex + idx)).join('\n')
+      text += `\n\n<i>Halaman ${currentPage}/${totalPages} (Total: ${totalItems})</i>`
+    }
+
+    const buttons: any[] = []
+
+    // Item buttons if defined
+    if (options.buttonText && options.buttonData) {
+      pageItems.forEach((item) => {
+        buttons.push([Markup.button.callback(options.buttonText!(item), options.buttonData!(item))])
+      })
+    }
+
+    // Navigation row
+    const navRow: any[] = []
+    if (currentPage > 1) {
+      navRow.push(Markup.button.callback('« Prev', `${prefix}:${currentPage - 1}`))
+    } else {
+      navRow.push(Markup.button.callback('·', 'noop'))
+    }
+
+    navRow.push(Markup.button.callback(`${currentPage}/${totalPages}`, 'noop'))
+
+    if (currentPage < totalPages) {
+      navRow.push(Markup.button.callback('Next »', `${prefix}:${currentPage + 1}`))
+    } else {
+      navRow.push(Markup.button.callback('·', 'noop'))
+    }
+
+    buttons.push(navRow)
+
+    return {
+      items: pageItems,
+      page: currentPage,
+      totalPages,
+      totalItems,
+      text,
+      keyboard: Markup.inlineKeyboard(buttons),
+    }
+  }
+}

package/src/reactions.ts

@@ -0,0 +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))
+  }
+}

package/src/router.ts

@@ -0,0 +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
+    })
+  }
+}

package/src/scenes/base.ts

@@ -0,0 +1,52 @@
+import { Middleware, MiddlewareFn } from '../middleware'
+import Composer from '../composer'
+import Context from '../context'
+
+const { compose } = Composer
+
+export interface SceneOptions<C extends Context> {
+  ttl?: number
+  handlers: ReadonlyArray<MiddlewareFn<C>>
+  enterHandlers: ReadonlyArray<MiddlewareFn<C>>
+  leaveHandlers: ReadonlyArray<MiddlewareFn<C>>
+}
+
+export class BaseScene<C extends Context = Context> extends Composer<C> {
+  id: string
+  ttl?: number
+  enterHandler: MiddlewareFn<C>
+  leaveHandler: MiddlewareFn<C>
+  constructor(id: string, options?: SceneOptions<C>) {
+    const opts: SceneOptions<C> = {
+      handlers: [],
+      enterHandlers: [],
+      leaveHandlers: [],
+      ...options,
+    }
+    super(...opts.handlers)
+    this.id = id
+    this.ttl = opts.ttl
+    this.enterHandler = compose(opts.enterHandlers)
+    this.leaveHandler = compose(opts.leaveHandlers)
+  }
+
+  enter(...fns: Array<Middleware<C>>) {
+    this.enterHandler = compose([this.enterHandler, ...fns])
+    return this
+  }
+
+  leave(...fns: Array<Middleware<C>>) {
+    this.leaveHandler = compose([this.leaveHandler, ...fns])
+    return this
+  }
+
+  enterMiddleware() {
+    return this.enterHandler
+  }
+
+  leaveMiddleware() {
+    return this.leaveHandler
+  }
+}
+
+export default BaseScene

package/src/scenes/context.ts

@@ -0,0 +1,136 @@
+import BaseScene from './base'
+import Composer from '../composer'
+import Context from '../context'
+import d from 'debug'
+import { SessionContext } from '../session'
+const debug = d('telegraf:scenes:context')
+
+const noop = () => Promise.resolve()
+const now = () => Math.floor(Date.now() / 1000)
+
+export interface SceneContext<D extends SceneSessionData = SceneSessionData>
+  extends Context {
+  session: SceneSession<D>
+  scene: SceneContextScene<SceneContext<D>, D>
+}
+
+export interface SceneSessionData {
+  current?: string
+  expires?: number
+  state?: object
+}
+
+export interface SceneSession<S extends SceneSessionData = SceneSessionData> {
+  __scenes?: S
+}
+
+export interface SceneContextSceneOptions<D extends SceneSessionData> {
+  ttl?: number
+  default?: string
+  defaultSession: D
+}
+
+export default class SceneContextScene<
+  C extends SessionContext<SceneSession<D>>,
+  D extends SceneSessionData = SceneSessionData,
+> {
+  private readonly options: SceneContextSceneOptions<D>
+
+  constructor(
+    private readonly ctx: C,
+    private readonly scenes: Map<string, BaseScene<C>>,
+    options: Partial<SceneContextSceneOptions<D>>
+  ) {
+    // @ts-expect-error {} might not be assignable to D
+    const fallbackSessionDefault: D = {}
+
+    this.options = { defaultSession: fallbackSessionDefault, ...options }
+  }
+
+  get session(): D {
+    const defaultSession = Object.assign({}, this.options.defaultSession)
+
+    let session = this.ctx.session?.__scenes ?? defaultSession
+    if (session.expires !== undefined && session.expires < now()) {
+      session = defaultSession
+    }
+    if (this.ctx.session === undefined) {
+      this.ctx.session = { __scenes: session }
+    } else {
+      this.ctx.session.__scenes = session
+    }
+    return session
+  }
+
+  get state() {
+    return (this.session.state ??= {})
+  }
+
+  set state(value) {
+    this.session.state = { ...value }
+  }
+
+  get current() {
+    const sceneId = this.session.current ?? this.options.default
+    return sceneId === undefined || !this.scenes.has(sceneId)
+      ? undefined
+      : this.scenes.get(sceneId)
+  }
+
+  reset() {
+    if (this.ctx.session !== undefined)
+      this.ctx.session.__scenes = Object.assign({}, this.options.defaultSession)
+  }
+
+  async enter(sceneId: string, initialState: object = {}, silent = false) {
+    if (!this.scenes.has(sceneId)) {
+      throw new Error(`Can't find scene: ${sceneId}`)
+    }
+    if (!silent) {
+      await this.leave()
+    }
+    debug('Entering scene', sceneId, initialState, silent)
+    this.session.current = sceneId
+    this.state = initialState
+    const ttl = this.current?.ttl ?? this.options.ttl
+    if (ttl !== undefined) {
+      this.session.expires = now() + ttl
+    }
+    if (this.current === undefined || silent) {
+      return
+    }
+    const handler =
+      'enterMiddleware' in this.current &&
+      typeof this.current.enterMiddleware === 'function'
+        ? this.current.enterMiddleware()
+        : this.current.middleware()
+    return await handler(this.ctx, noop)
+  }
+
+  reenter() {
+    return this.session.current === undefined
+      ? undefined
+      : this.enter(this.session.current, this.state)
+  }
+
+  private leaving = false
+  async leave() {
+    if (this.leaving) return
+    debug('Leaving scene')
+    try {
+      this.leaving = true
+      if (this.current === undefined) {
+        return
+      }
+      const handler =
+        'leaveMiddleware' in this.current &&
+        typeof this.current.leaveMiddleware === 'function'
+          ? this.current.leaveMiddleware()
+          : Composer.passThru()
+      await handler(this.ctx, noop)
+      return this.reset()
+    } finally {
+      this.leaving = false
+    }
+  }
+}

package/src/scenes/form-scene.ts

@@ -0,0 +1,34 @@
+import { Composer } from '../composer'
+import { Context } from '../context'
+
+export interface FormStepOptions<C extends Context = Context> {
+  prompt: string | ((ctx: C) => string | Promise<string>)
+  field: string
+  validate?: (input: string, ctx: C) => boolean | string | Promise<boolean | string>
+  type?: 'text' | 'number'
+}
+
+export class FormScene<C extends Context = Context> extends Composer<C> {
+  readonly id: string
+  private steps: FormStepOptions<C>[] = []
+  private completionHandler?: (ctx: C, data: Record<string, any>) => any
+
+  constructor(id: string) {
+    super()
+    this.id = id
+  }
+
+  field(field: string, options: Omit<FormStepOptions<C>, 'field'>): this {
+    this.steps.push({ field, ...options })
+    return this
+  }
+
+  onComplete(handler: (ctx: C, data: Record<string, any>) => any): this {
+    this.completionHandler = handler
+    return this
+  }
+
+  getSteps(): FormStepOptions<C>[] {
+    return this.steps
+  }
+}

package/src/scenes/index.ts

@@ -0,0 +1,21 @@
+/**
+ * @see https://github.com/telegraf/telegraf/issues/705#issuecomment-549056045
+ * @see https://www.npmjs.com/package/telegraf-stateless-question
+ * @packageDocumentation
+ */
+
+export { Stage } from './stage'
+export {
+  SceneContext,
+  SceneSession,
+  default as SceneContextScene,
+  SceneSessionData,
+} from './context'
+export { BaseScene } from './base'
+export { WizardScene } from './wizard'
+export {
+  WizardContext,
+  WizardSession,
+  default as WizardContextWizard,
+  WizardSessionData,
+} from './wizard/context'