dfx 1.0.5 → 1.0.7

package/dist/src/Helpers/ui.ts

@@ -1,253 +0,0 @@
-import type {
-  ActionRowComponentForMessageRequest,
-  ActionRowComponentForModalRequest,
-  ButtonComponentForMessageRequest,
-  ChannelSelectComponentForMessageRequest,
-  ContainerComponentForMessageRequest,
-  FileComponentForMessageRequest,
-  MediaGalleryComponentForMessageRequest,
-  MentionableSelectComponentForMessageRequest,
-  MessageCreateRequest,
-  PollAnswerCreateRequest,
-  PollCreateRequest,
-  PollMediaCreateRequest,
-  RoleSelectComponentForMessageRequest,
-  SectionComponentForMessageRequest,
-  SeparatorComponentForMessageRequest,
-  StringSelectComponentForMessageRequest,
-  TextDisplayComponentForMessageRequest,
-  TextInputComponentForModalRequest,
-  ThumbnailComponentForMessageRequest,
-  UserSelectComponentForMessageRequest,
-} from "../types.ts"
-import {
-  TextInputStyleTypes,
-  ButtonStyleTypes,
-  MessageComponentTypes,
-  MessageFlags,
-} from "../types.ts"
-
-type ActionRowComponents = ReadonlyArray<
-  | ActionRowComponentForMessageRequest["components"][number]
-  | ActionRowComponentForModalRequest["components"][number]
->
-
-/**
- * Helper to create an Action Row.
- */
-export const row = <const C extends ActionRowComponents>(
-  components: C,
-): {
-  readonly type: typeof MessageComponentTypes.ACTION_ROW
-  readonly components: C
-} => ({
-  type: MessageComponentTypes.ACTION_ROW,
-  components,
-})
-
-/**
- * Helper to create an Action Row grid.
- */
-export const grid = <C extends ActionRowComponents>(
-  items: ReadonlyArray<C>,
-): ReadonlyArray<{
-  readonly type: typeof MessageComponentTypes.ACTION_ROW
-  readonly components: C
-}> => items.map(row)
-
-/**
- * Helper to create a single column of components
- */
-export const singleColumn = <C extends ActionRowComponents>(
-  items: C,
-): ReadonlyArray<{
-  readonly type: typeof MessageComponentTypes.ACTION_ROW
-  readonly components: C
-}> => items.map(c => row([c as any])) as any
-
-/**
- * Helper to create a button component.
- */
-export const button = (
-  options: Partial<ButtonComponentForMessageRequest>,
-): ButtonComponentForMessageRequest => ({
-  type: MessageComponentTypes.BUTTON,
-  style: ButtonStyleTypes.PRIMARY,
-  ...options,
-})
-
-/**
- * Helper to create a select component.
- */
-export const select = (
-  options: Omit<StringSelectComponentForMessageRequest, "type">,
-): StringSelectComponentForMessageRequest => ({
-  type: MessageComponentTypes.STRING_SELECT,
-  ...options,
-})
-
-/**
- * Helper to create a select component.
- */
-export const userSelect = (
-  options: Omit<UserSelectComponentForMessageRequest, "type">,
-): UserSelectComponentForMessageRequest => ({
-  type: MessageComponentTypes.USER_SELECT,
-  ...options,
-})
-
-/**
- * Helper to create a select component.
- */
-export const roleSelect = (
-  options: Omit<RoleSelectComponentForMessageRequest, "type">,
-): RoleSelectComponentForMessageRequest => ({
-  type: MessageComponentTypes.ROLE_SELECT,
-  ...options,
-})
-
-/**
- * Helper to create a select component.
- */
-export const mentionableSelect = (
-  options: Omit<MentionableSelectComponentForMessageRequest, "type">,
-): MentionableSelectComponentForMessageRequest => ({
-  type: MessageComponentTypes.MENTIONABLE_SELECT,
-  ...options,
-})
-
-/**
- * Helper to create a select component.
- */
-export const channelSelect = (
-  options: Omit<ChannelSelectComponentForMessageRequest, "type">,
-): ChannelSelectComponentForMessageRequest => ({
-  type: MessageComponentTypes.CHANNEL_SELECT,
-  ...options,
-})
-
-type TextInputOpts = Omit<
-  TextInputComponentForModalRequest,
-  "type" | "style"
-> & {
-  style?: TextInputStyleTypes
-}
-
-/**
- * Helper to create a text input
- */
-export const textInput = (
-  input: TextInputOpts,
-): TextInputComponentForModalRequest => ({
-  type: MessageComponentTypes.TEXT_INPUT,
-  style: TextInputStyleTypes.SHORT,
-  ...input,
-})
-
-/**
- * Helper to create a poll
- */
-export const poll = (
-  input: Omit<PollCreateRequest, "answers"> & {
-    readonly answers: ReadonlyArray<PollMediaCreateRequest>
-  },
-): PollCreateRequest => ({
-  ...input,
-  answers: input.answers.map(
-    poll_media => ({ poll_media }) as PollAnswerCreateRequest,
-  ),
-})
-
-/**
- * Helper to create a media gallery
- */
-export const mediaGallery = (
-  options: Omit<MediaGalleryComponentForMessageRequest, "type">,
-): MediaGalleryComponentForMessageRequest => ({
-  type: MessageComponentTypes.MEDIA_GALLERY,
-  ...options,
-})
-
-/**
- * Helper to create a file component
- */
-export const file = (
-  options: Omit<FileComponentForMessageRequest, "type">,
-): FileComponentForMessageRequest => ({
-  type: MessageComponentTypes.FILE,
-  ...options,
-})
-
-/**
- * Helper to create a container component
- */
-export const container = (
-  options: Omit<ContainerComponentForMessageRequest, "type">,
-): ContainerComponentForMessageRequest => ({
-  type: MessageComponentTypes.CONTAINER,
-  ...options,
-})
-
-/**
- * Helper to create a section component
- */
-export const section = (
-  options: Omit<SectionComponentForMessageRequest, "type">,
-): SectionComponentForMessageRequest => ({
-  type: MessageComponentTypes.SECTION,
-  ...options,
-})
-
-/**
- * Helper to create a thumbnail component
- */
-export const thumbnail = (options: {
-  readonly url: string
-  readonly description?: string | undefined
-  readonly spoiler?: boolean | undefined
-}): ThumbnailComponentForMessageRequest => ({
-  type: MessageComponentTypes.THUMBNAIL,
-  description: options.description,
-  spoiler: options.spoiler,
-  media: { url: options.url },
-})
-
-/**
- * Helper to create a separator component
- */
-export const seperator = (
-  options?: Omit<SeparatorComponentForMessageRequest, "type">,
-): SeparatorComponentForMessageRequest => ({
-  type: MessageComponentTypes.SEPARATOR,
-  ...options,
-})
-
-/**
- * Helper to create a text display component
- */
-export const textDisplay = (
-  content: string,
-): TextDisplayComponentForMessageRequest => ({
-  type: MessageComponentTypes.TEXT_DISPLAY,
-  content,
-})
-
-type MessageComponents = NonNullable<MessageCreateRequest["components"]>[number]
-
-/**
- * Create a components v2 message
- */
-export const components = <const C extends ReadonlyArray<MessageComponents>>(
-  items: C,
-  options?: {
-    readonly ephemeral?: boolean | undefined
-  },
-): {
-  readonly flags: MessageFlags
-  readonly components: C
-} => ({
-  flags: options?.ephemeral
-    ? MessageFlags.Ephemeral | MessageFlags.IsComponentsV2
-    : MessageFlags.IsComponentsV2,
-  components: items,
-})

package/dist/src/Interactions/builder.ts

@@ -1,171 +0,0 @@
-import * as Chunk from "effect/Chunk"
-import { identity } from "effect/Function"
-import type * as Cause from "effect/Cause"
-import * as Effect from "effect/Effect"
-import { catchTag } from "effect/Effect"
-import type { DiscordRESTError } from "../DiscordREST.ts"
-import { DiscordREST } from "../DiscordREST.ts"
-import type * as D from "./definitions.ts"
-import type * as Discord from "../types.ts"
-
-type ExtractTag<A> = A extends { _tag: infer Tag }
-  ? Tag extends string
-    ? Tag
-    : never
-  : never
-
-export class InteractionBuilder<R, E, TE> {
-  constructor(
-    readonly definitions: Chunk.Chunk<
-      readonly [
-        handler: D.InteractionDefinition<R, E>,
-        transform: (
-          self: Effect.Effect<any, any, any>,
-        ) => Effect.Effect<void, TE, R>,
-      ]
-    >,
-    readonly transform: (
-      self: Effect.Effect<any, any, any>,
-    ) => Effect.Effect<void, TE, R>,
-  ) {}
-
-  add<R1, E1>(definition: D.InteractionDefinition<R1, E1>) {
-    return new InteractionBuilder<R | R1, E | E1, TE | E1>(
-      Chunk.append(this.definitions, [definition, this.transform] as const),
-      this.transform,
-    )
-  }
-
-  concat<R1, E1, TE1>(builder: InteractionBuilder<R1, E1, TE1>) {
-    return new InteractionBuilder<R | R1, E | E1, TE | TE1>(
-      Chunk.appendAll(this.definitions, builder.definitions),
-      this.transform,
-    )
-  }
-
-  private transformTransform<R1, E1>(
-    f: (selr: Effect.Effect<void, TE, R>) => Effect.Effect<void, E1, R1>,
-  ) {
-    return new InteractionBuilder<R1, E, E1>(
-      Chunk.map(this.definitions, ([d, t]) => [d as any, _ => f(t(_)) as any]),
-      _ => f(this.transform(_)) as any,
-    )
-  }
-
-  private transformHandlers<R1, E1>(
-    f: (
-      self: Effect.Effect<Discord.CreateInteractionResponseRequest, E, R>,
-    ) => Effect.Effect<Discord.CreateInteractionResponseRequest, E1, R1>,
-  ) {
-    return new InteractionBuilder<
-      R1,
-      E1,
-      Exclude<TE, Exclude<E, E1>> | Exclude<E1, E>
-    >(
-      Chunk.map(this.definitions, ([d, t]) => [
-        {
-          ...d,
-          handle: Effect.isEffect(d.handle)
-            ? f(d.handle)
-            : (_: any) => f((d.handle as any)(_)),
-        } as any,
-        t as any,
-      ]),
-      this.transform as any,
-    )
-  }
-
-  catchAllCause<R1, E1>(
-    f: (cause: Cause.Cause<TE>) => Effect.Effect<void, E1, R1>,
-  ) {
-    return this.transformTransform<R | R1, E1>(Effect.catchCause(f))
-  }
-
-  catchAllCauseRespond<R1, E1>(
-    f: (
-      cause: Cause.Cause<E>,
-    ) => Effect.Effect<Discord.CreateInteractionResponseRequest, E1, R1>,
-  ) {
-    return this.transformHandlers<R | R1, E1>(Effect.catchCause(f))
-  }
-
-  catchAll<R1, E1>(f: (error: TE) => Effect.Effect<void, E1, R1>) {
-    return this.transformTransform<R | R1, E1>(Effect.catch(f))
-  }
-
-  catchAllRespond<R1, E1>(
-    f: (
-      error: E,
-    ) => Effect.Effect<Discord.CreateInteractionResponseRequest, E1, R1>,
-  ) {
-    return this.transformHandlers<R | R1, E1>(Effect.catch(f))
-  }
-
-  catchTag<T extends ExtractTag<E>, R1, E1>(
-    tag: T,
-    f: (error: Extract<TE, { _tag: T }>) => Effect.Effect<void, E1, R1>,
-  ) {
-    return this.transformTransform<R | R1, Exclude<TE, { _tag: T }> | E1>(
-      _ => catchTag(_ as any, tag, f as any) as any,
-    )
-  }
-
-  catchTagRespond<T extends ExtractTag<E>, R1, E1>(
-    tag: T,
-    f: (
-      error: Extract<E, { _tag: T }>,
-    ) => Effect.Effect<Discord.CreateInteractionResponseRequest, E1, R1>,
-  ) {
-    return this.transformHandlers<R | R1, Exclude<E, { _tag: T }> | E1>(
-      _ => catchTag(_ as any, tag, f as any) as any,
-    )
-  }
-
-  get syncGlobal() {
-    const commands = this.definitions.pipe(
-      Chunk.map(([d, _]) => d),
-      Chunk.filter(
-        (c): c is D.GlobalApplicationCommand<R, E> =>
-          c._tag === "GlobalApplicationCommand",
-      ),
-      Chunk.map(c => c.command),
-    )
-
-    return DiscordREST.use(rest =>
-      rest
-        .getMyApplication()
-        .pipe(
-          Effect.flatMap(app =>
-            rest.bulkSetApplicationCommands(
-              app.id,
-              Chunk.toReadonlyArray(commands),
-            ),
-          ),
-        ),
-    )
-  }
-
-  syncGuild(appId: Discord.Snowflake, guildId: Discord.Snowflake) {
-    const commands = this.definitions.pipe(
-      Chunk.map(([d, _]) => d),
-      Chunk.filter(
-        (c): c is D.GuildApplicationCommand<R, E> =>
-          c._tag === "GuildApplicationCommand",
-      ),
-      Chunk.map(c => c.command),
-    )
-
-    return DiscordREST.use(rest =>
-      rest.bulkSetGuildApplicationCommands(
-        appId,
-        guildId,
-        Chunk.toReadonlyArray(commands),
-      ),
-    )
-  }
-}
-
-export const builder = new InteractionBuilder<never, never, DiscordRESTError>(
-  Chunk.empty(),
-  identity as any,
-)

package/dist/src/Interactions/commandHelper.ts

@@ -1,231 +0,0 @@
-import * as Option from "effect/Option"
-import * as Effect from "effect/Effect"
-import {
-  type DiscordSubCommand,
-  SubCommandContext,
-  SubCommandNotFound,
-  type DiscordApplicationCommand,
-  type DiscordInteraction,
-} from "./context.ts"
-import type * as Discord from "../types.ts"
-import * as Helpers from "../Helpers/interactions.ts"
-import * as Arr from "effect/Array"
-import type { HashMap } from "effect/HashMap"
-
-export class CommandHelper<A> {
-  constructor(readonly interaction: Discord.APIInteraction) {
-    this.target = Helpers.target(interaction.data as any) as any
-    this.data = interaction.data as any
-  }
-  readonly data: Discord.APIApplicationCommandInteraction["data"]
-  readonly target: CommandTypeMap<
-    A,
-    {
-      [Discord.ApplicationCommandType
-        .CHAT]: Discord.APIChatInputApplicationCommandGuildInteraction["data"]
-      [Discord.ApplicationCommandType.MESSAGE]: Discord.MessageResponse
-      [Discord.ApplicationCommandType.USER]: Discord.UserResponse
-      [Discord.ApplicationCommandType.PRIMARY_ENTRY_POINT]: undefined
-    }
-  >
-
-  resolve<T>(
-    name: AllResolvables<A>["name"],
-    f: (
-      id: Discord.Snowflake,
-      data: Discord.InteractionDataResolved,
-    ) => T | undefined,
-  ): Option.Option<T> {
-    return Helpers.resolveOptionValue(name, f)(this.interaction)
-  }
-
-  resolvedValues<T>(
-    f: (
-      id: Discord.Snowflake,
-      data: Discord.InteractionDataResolved,
-    ) => T | undefined,
-  ): Option.Option<ReadonlyArray<T>> {
-    return Helpers.resolveValues(f)(this.interaction)
-  }
-
-  option(
-    name: AllCommandOptions<A>["name"],
-  ): Option.Option<Discord.APIApplicationCommandInteractionDataOption> {
-    return Helpers.getOption(name)(this.data as any)
-  }
-
-  optionValue<N extends AllRequiredCommandOptions<A>["name"]>(
-    name: N,
-  ): CommandValue<A, N> {
-    return Option.getOrThrow(this.optionValueOptional(name))
-  }
-
-  optionValueOptional<N extends AllCommandOptions<A>["name"]>(
-    name: N,
-  ): Option.Option<CommandValue<A, N>> {
-    return Option.map(this.option(name), _ => (_ as any).value) as any
-  }
-
-  optionValueOrElse<N extends AllCommandOptions<A>["name"], const OrElse>(
-    name: N,
-    orElse: () => OrElse,
-  ): CommandValue<A, N> {
-    return Option.getOrElse(this.optionValueOptional(name), orElse) as any
-  }
-
-  subCommands<
-    NER extends SubCommandNames<A> extends never
-      ? never
-      : Record<
-          SubCommandNames<A>,
-          Effect.Effect<Discord.CreateInteractionResponseRequest, any, any>
-        >,
-  >(
-    commands: NER,
-  ): Effect.Effect<
-    Effect.Success<NER[keyof NER]>,
-    Effect.Error<NER[keyof NER]>,
-    | Exclude<Effect.Services<NER[keyof NER]>, DiscordSubCommand>
-    | DiscordInteraction
-    | DiscordApplicationCommand
-  > {
-    const commands_ = commands as Record<string, any>
-    const matchedCommand = Arr.findFirst(
-      Helpers.allSubCommands(this.data),
-      _ => !!commands_[_.name],
-    )
-
-    return Option.match(matchedCommand, {
-      onNone: () => Effect.fail(new SubCommandNotFound({ data: this.data })),
-      onSome: subCommand =>
-        Effect.provideService(commands_[subCommand.name], SubCommandContext, {
-          command: subCommand,
-        }),
-    }) as any
-  }
-
-  get optionsMap(): HashMap<string, string | undefined> {
-    return Helpers.optionsMap(this.data as any)
-  }
-}
-
-export type CommandHandlerFn<R, E, A> = (
-  i: CommandHelper<A>,
-) => Effect.Effect<Discord.CreateInteractionResponseRequest, E, R>
-
-interface CommandOption {
-  readonly type: any
-  readonly name: string
-  readonly options?: ReadonlyArray<CommandOption>
-}
-
-type CommandTypeMap<
-  A,
-  Options extends Record<Discord.ApplicationCommandType, any>,
-> = A extends { readonly type: infer T }
-  ? T extends keyof Options
-    ? Options[T]
-    : never
-  : Options[typeof Discord.ApplicationCommandType.CHAT]
-
-// == Sub commands
-type SubCommands<A> = A extends {
-  readonly type: typeof Discord.ApplicationCommandOptionType.SUB_COMMAND
-  readonly options?: ReadonlyArray<CommandOption>
-}
-  ? A
-  : A extends { readonly options: ReadonlyArray<CommandOption> }
-    ? SubCommands<A["options"][number]>
-    : never
-
-type SubCommandNames<A> = Option<SubCommands<A>>["name"]
-
-// == Command options
-type CommandOptionType = Exclude<
-  Discord.ApplicationCommandOptionType,
-  | typeof Discord.ApplicationCommandOptionType.SUB_COMMAND
-  | typeof Discord.ApplicationCommandOptionType.SUB_COMMAND_GROUP
->
-
-type CommandOptions<A> = OptionsWithLiteral<
-  A,
-  {
-    readonly type: CommandOptionType
-  }
->
-
-type SubCommandOptions<A> = Extract<
-  Option<Exclude<SubCommands<A>["options"], undefined>[number]>,
-  {
-    readonly type: CommandOptionType
-  }
->
-
-type AllCommandOptions<A> = CommandOptions<A> | SubCommandOptions<A>
-
-type CommandWithName<A, N> = Extract<AllCommandOptions<A>, { readonly name: N }>
-
-type OptionTypeValue = {
-  [Discord.ApplicationCommandOptionType.BOOLEAN]: boolean
-  [Discord.ApplicationCommandOptionType.INTEGER]: number
-  [Discord.ApplicationCommandOptionType.NUMBER]: number
-}
-type CommandValue<A, N> = CommandWithName<
-  A,
-  N
->["type"] extends keyof OptionTypeValue
-  ? OptionTypeValue[CommandWithName<A, N>["type"]]
-  : string
-
-// == Required options
-type RequiredCommandOptions<A> = OptionsWithLiteral<
-  A,
-  {
-    readonly type: CommandOptionType
-    readonly required: true
-  }
->
-
-type RequiredSubCommandOptions<A> = Extract<
-  SubCommandOptions<A>,
-  { readonly required: true }
->
-
-type AllRequiredCommandOptions<A> =
-  | RequiredCommandOptions<A>
-  | RequiredSubCommandOptions<A>
-
-// == Resolveables
-type ResolvableType =
-  | typeof Discord.ApplicationCommandOptionType.ROLE
-  | typeof Discord.ApplicationCommandOptionType.USER
-  | typeof Discord.ApplicationCommandOptionType.MENTIONABLE
-  | typeof Discord.ApplicationCommandOptionType.CHANNEL
-
-type Resolvables<A> = OptionsWithLiteral<A, { readonly type: ResolvableType }>
-type SubCommandResolvables<A> = Extract<
-  Option<Exclude<SubCommands<A>["options"], undefined>[number]>,
-  {
-    readonly type: ResolvableType
-  }
->
-type AllResolvables<A> = Resolvables<A> | SubCommandResolvables<A>
-
-// == Utilities
-type StringLiteral<T> = T extends string
-  ? string extends T
-    ? never
-    : T
-  : never
-
-type Option<A> = A extends { readonly name: infer N }
-  ? N extends StringLiteral<N>
-    ? A
-    : never
-  : never
-
-type OptionsWithLiteral<A, T> = A extends {
-  readonly options: ReadonlyArray<CommandOption>
-}
-  ? Extract<A["options"][number], Option<A["options"][number]> & T>
-  : never