123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188
import { Interaction } from './src/structures/interactions.ts'import {  ApplicationCommandsManager,  InteractionsClient,  ApplicationCommandHandler,  ApplicationCommandHandlerCallback,  AutocompleteHandlerCallback} from './src/interactions/mod.ts'import {  InteractionResponseType,  InteractionType} from './src/types/interactions.ts'import { ApplicationCommandType } from './src/types/applicationCommand.ts'
export interface DeploySlashInitOptions {  env?: boolean  publicKey?: string  token?: string  path?: string}
/** Current Slash Client being used to handle commands */let client: InteractionsClient/** Manage Slash Commands right in Deploy */let commands: ApplicationCommandsManager
/** * Initialize Slash Commands Handler for [Deno Deploy](https://deno.com/deploy). * Easily create Serverless Slash Commands on the fly. * * **Examples** * * ```ts * init({ *   publicKey: "my public key", *   token: "my bot's token", // only required if you want to manage slash commands in code * }) * ``` * * ```ts * // takes up `PUBLIC_KEY` and `TOKEN` from ENV * init({ env: true }) * ``` * * @param options Initialization options */export function init(options: { env: boolean; path?: string }): voidexport function init(options: {  publicKey: string  token?: string  path?: string}): voidexport function init(options: DeploySlashInitOptions): void {  if (client !== undefined) throw new Error('Already initialized')  if (options.env === true) {    options.publicKey = Deno.env.get('PUBLIC_KEY')    options.token = Deno.env.get('TOKEN')  }
  if (options.publicKey === undefined)    throw new Error('Public Key not provided')
  client = new InteractionsClient({    token: options.token,    publicKey: options.publicKey  })
  commands = client.commands
  const cb = async (evt: {    respondWith: CallableFunction    request: Request  }): Promise<void> => {    if (options.path !== undefined) {      if (new URL(evt.request.url).pathname !== options.path) return    }    try {      // we have to wrap because there are some weird scope errors      const d = await client.verifyFetchEvent({        respondWith: (...args: unknown[]) => evt.respondWith(...args),        request: evt.request      })      if (d === false) {        await evt.respondWith(          new Response('Not Authorized', {            status: 400          })        )        return      }
      if (d.type === InteractionType.PING) {        await d.respond({ type: InteractionResponseType.PONG })        client.emit('ping')        return      }
      await client._process(d)    } catch (e) {      await client.emit('interactionError', e as Error)    }  }
  addEventListener('fetch', cb as unknown as EventListener)}
/** * Register Slash Command handler. * * Example: * * ```ts * handle("ping", (interaction) => { *   interaction.reply("Pong!") * }) * ``` * * Also supports Sub Command and Group handling out of the box! * ```ts * handle("command-name group-name sub-command", (i) => { *   // ... * }) * * handle("command-name sub-command", (i) => { *   // ... * }) * ``` * * @param cmd Command to handle. Either Handler object or command name followed by handler function in next parameter. * @param handler Handler function (required if previous argument was command name) */export function handle(  cmd: string,  handler: ApplicationCommandHandlerCallback): voidexport function handle(cmd: ApplicationCommandHandler): voidexport function handle(  cmd: string,  handler: ApplicationCommandHandlerCallback,  type: ApplicationCommandType | keyof typeof ApplicationCommandType): voidexport function handle(  cmd: string | ApplicationCommandHandler,  handler?: ApplicationCommandHandlerCallback,  type?: ApplicationCommandType | keyof typeof ApplicationCommandType): void {  if (client === undefined)    throw new Error('Interaction Client not initialized. Call `init` first')
  if (    typeof cmd === 'string' &&    typeof handler === 'function' &&    typeof type !== 'undefined'  ) {    client.handle(cmd, handler, type)  } else if (typeof cmd === 'string' && typeof handler === 'function') {    client.handle(cmd, handler)  } else if (typeof cmd === 'object') {    client.handle(cmd)  } else throw new Error('Invalid overload for `handle` function')}
export function autocomplete(  cmd: string,  option: string,  callback: AutocompleteHandlerCallback): void {  client.autocomplete(cmd, option, callback)}
/** Listen for Interactions Event */export function interactions(  cb: (i: Interaction) => unknown | Promise<unknown>): void {  client.on('interaction', cb)}
export { commands, client }export * from './src/types/applicationCommand.ts'export * from './src/types/interactions.ts'export * from './src/structures/applicationCommand.ts'export * from './src/interactions/mod.ts'export * from './src/types/channel.ts'export * from './src/structures/interactions.ts'export * from './src/structures/message.ts'export * from './src/structures/embed.ts'export * from './src/types/messageComponents.ts'