dfx 0.9.7 → 0.9.8

package/src/Helpers/interactions.ts

@@ -1,180 +0,0 @@
-import * as Arr from "@fp-ts/data/ReadonlyArray"
-
-/**
- * Maybe find a sub-command within the interaction options.
- */
-export const allSubCommands = (interaction: Discord.ApplicationCommandDatum) =>
-  pipe(
-    optionsWithNested(interaction),
-    Arr.filter(
-      (o) => o.type === Discord.ApplicationCommandOptionType.SUB_COMMAND,
-    ),
-  )
-
-/**
- * Maybe find a sub-command within the interaction options.
- */
-export const findSubCommand =
-  (name: string) => (interaction: Discord.ApplicationCommandDatum) =>
-    pipe(
-      optionsWithNested(interaction),
-      Arr.findFirst(
-        (o) =>
-          o.type === Discord.ApplicationCommandOptionType.SUB_COMMAND &&
-          o.name === name,
-      ),
-    )
-
-/**
- * If the sub-command exists return `true`, else `false`.
- */
-export const isSubCommand = (name: string) =>
-  flow(findSubCommand(name), (o) => o.isSome)
-
-/**
- * Maybe get the options for a sub-command
- */
-export const subCommandOptions = (name: string) =>
-  flow(findSubCommand(name), (o) => o.flatMapNullable((o) => o.options))
-
-/**
- * A lens for accessing nested options in a interaction.
- */
-export const optionsWithNested = (
-  data: Pick<Discord.ApplicationCommandDatum, "options">,
-): Discord.ApplicationCommandInteractionDataOption[] => {
-  const optsFromOption = (
-    opt: Discord.ApplicationCommandInteractionDataOption,
-  ): Discord.ApplicationCommandInteractionDataOption[] =>
-    Maybe.fromNullable(opt.options)
-      .map((opts) => [...opts, ...opts.flatMap(optsFromOption)])
-      .match(() => [], identity)
-
-  return Maybe.fromNullable(data.options)
-    .map((opts) => [...opts, ...opts.flatMap(optsFromOption)])
-    .getOrElse(() => [])
-}
-
-/**
- * Return the interaction options as a name / value map.
- */
-export const transformOptions = (
-  options: Discord.ApplicationCommandInteractionDataOption[],
-) =>
-  options.reduce(
-    (map, option) => ({
-      ...map,
-      [option.name]: option.value,
-    }),
-    {} as Record<string, string | undefined>,
-  )
-
-/**
- * Return the interaction options as a name / value map.
- */
-export const optionsMap = flow(optionsWithNested, transformOptions)
-
-/**
- * Try find a matching option from the interaction.
- */
-export const getOption = (name: string) =>
-  flow(
-    optionsWithNested,
-    Arr.findFirst((o) => o.name === name),
-  )
-
-/**
- * Try find a matching option from the interaction.
- */
-export const focusedOption = flow(
-  optionsWithNested,
-  Arr.findFirst((o) => o.focused === true),
-)
-
-/**
- * Try find a matching option value from the interaction.
- */
-export const optionValue = (name: string) =>
-  flow(getOption(name), (o) => o.flatMapNullable((o) => o.value))
-
-/**
- * Try extract resolved data
- */
-export const resolved = (data: Discord.ApplicationCommandDatum) =>
-  Maybe.fromNullable(data.resolved)
-
-/**
- * Try find a matching option value from the interaction.
- */
-export const resolveOptionValue =
-  <T>(
-    name: string,
-    f: (id: Discord.Snowflake, data: Discord.ResolvedDatum) => T | undefined,
-  ) =>
-  (a: Discord.ApplicationCommandDatum): Maybe<T> =>
-    Do(($) => {
-      const id = $(
-        getOption(name)(a).flatMapNullable(
-          ({ value }) => value as Discord.Snowflake,
-        ),
-      )
-      const data = $(resolved(a))
-      return $(Maybe.fromNullable(f(id, data)))
-    })
-
-const extractComponents = (c: Discord.Component): Discord.Component[] => {
-  if ("components" in c) {
-    return [...c.components, ...c.components.flatMap(extractComponents)]
-  }
-
-  return []
-}
-
-/**
- * A lens for accessing the components in a interaction.
- */
-export const components = (
-  a: Discord.ModalSubmitDatum,
-): Discord.Component[] => [
-  ...a.components,
-  ...a.components.flatMap(extractComponents),
-]
-
-/**
- * A lens for accessing the components in a interaction.
- */
-export const componentsWithValue = flow(
-  components,
-  Arr.filter((c) => "value" in c && c.value !== undefined),
-)
-
-/**
- * Return the interaction components as an id / value map.
- */
-export const transformComponents = (options: Discord.Component[]) =>
-  (options as Discord.TextInput[]).reduce(
-    (map, c) => (c.custom_id ? { ...map, [c.custom_id]: c.value } : map),
-    {} as Record<string, string | undefined>,
-  )
-
-/**
- * Return the interaction components as an id / value map.
- */
-export const componentsMap = flow(components, transformComponents)
-
-/**
- * Try find a matching component from the interaction.
- */
-export const getComponent = (id: string) =>
-  flow(
-    components,
-    Arr.findFirst((o) => (o as Discord.TextInput).custom_id === id),
-  )
-
-/**
- * Try find a matching component value from the interaction.
- */
-export const componentValue = (id: string) =>
-  flow(getComponent(id), (o) =>
-    o.flatMapNullable((o) => (o as Discord.TextInput).value),
-  )

package/src/Helpers/members.ts

@@ -1,14 +0,0 @@
-/**
- * From a list of roles, filter out the ones the guild member has.
- */
-export const roles = (roles: Discord.Role[]) => (member: Discord.GuildMember) =>
-  roles.filter(
-    (role) => member.roles.includes(role.id) || role.name === "@everyone",
-  )
-
-/**
- * Type-guard function for checking if the object is a guild member
- */
-export const is = (thing: unknown): thing is Discord.GuildMember =>
-  Object.prototype.hasOwnProperty.call(thing, "roles") &&
-  Object.prototype.hasOwnProperty.call(thing, "joined_at")

package/src/Helpers/permissions.ts

@@ -1,102 +0,0 @@
-/**
- * A constant of all the permissions
- */
-export const ALL = Flags.all(Discord.PermissionFlag)
-
-/**
- * Check if a flag exists in the permissions.
- */
-export const has = Flags.hasBigInt
-
-/**
- * Convert a permissions bitfield to a list of flag names.
- */
-export const toList = Flags.toList(Discord.PermissionFlag)
-
-/**
- * Convert a list of flag names to a bitfield.
- */
-export const fromList = Flags.fromListBigint(Discord.PermissionFlag)
-
-/**
- * Reduce a list of roles to a bitfield of all the permissions added together.
- */
-export const forRoles = (roles: Discord.Role[]) =>
-  roles.reduce(
-    (permissions, role) => permissions | BigInt(role.permissions),
-    BigInt(0),
-  )
-
-/**
- * From a list of roles, calculate the permissions bitfield for the member.
- */
-export const forMember =
-  (roles: Discord.Role[]) => (member: Discord.GuildMember) =>
-    pipe(Members.roles(roles)(member), forRoles)
-
-const overwriteIsForMember =
-  (guildId?: string) =>
-  (member: Discord.GuildMember) =>
-  (overwrite: Discord.Overwrite) => {
-    if (overwrite.type === 0) {
-      return overwrite.id === guildId || member.roles.includes(overwrite.id)
-    }
-    return overwrite.id === member.user?.id
-  }
-
-const overwriteIsForRole =
-  (guildId?: string) =>
-  (role: Discord.Role) =>
-  (overwrite: Discord.Overwrite) => {
-    if (overwrite.type === 0) {
-      return overwrite.id === guildId || overwrite.id === role.id
-    }
-
-    return false
-  }
-
-/**
- * From a list of roles and a channel, calculate the permission bitfield for
- * the guild member or role for that channel.
- */
-export const forChannel =
-  (roles: Discord.Role[]) =>
-  ({ guild_id, permission_overwrites: overwrites = [] }: Discord.Channel) =>
-  (memberOrRole: Discord.GuildMember | Discord.Role) => {
-    const hasAdmin = has(Discord.PermissionFlag.ADMINISTRATOR)
-    let basePermissions: bigint
-    let filteredOverwrites: Discord.Overwrite[]
-
-    if (Members.is(memberOrRole)) {
-      if (memberOrRole.permissions) return BigInt(memberOrRole.permissions)
-
-      const memberRoles = Members.roles(roles)(memberOrRole)
-      basePermissions = forRoles(memberRoles)
-      filteredOverwrites = overwrites.filter(
-        overwriteIsForMember(guild_id)(memberOrRole),
-      )
-    } else {
-      const everyone = roles.find((role) => role.name === "@everyone")
-      basePermissions =
-        BigInt(everyone?.permissions || "0") | BigInt(memberOrRole.permissions)
-      filteredOverwrites = overwrites.filter(
-        overwriteIsForRole(guild_id)(memberOrRole),
-      )
-    }
-
-    if (hasAdmin(basePermissions)) {
-      return ALL
-    }
-    return applyOverwrites(basePermissions)(filteredOverwrites)
-  }
-
-/**
- * Apply permission overwrites to a bitfield.
- */
-export const applyOverwrites =
-  (permissions: bigint) => (overwrites: Discord.Overwrite[]) =>
-    overwrites.reduce(
-      (permissions, overwrite) =>
-        (permissions & ~BigInt(overwrite.deny)) | BigInt(overwrite.allow),
-      permissions,
-    )

package/src/Helpers/ui.ts

@@ -1,103 +0,0 @@
-import {
-  ActionRow,
-  Button,
-  ButtonStyle,
-  Component,
-  ComponentType,
-  SelectMenu,
-  SelectOption,
-  TextInput,
-  TextInputStyle,
-} from "../types.js"
-
-export type UIComponent = Exclude<Component, ActionRow>
-
-/**
- * Helper to create an Action Row grid.
- */
-export const grid = (items: UIComponent[][]): ActionRow[] =>
-  items.map(
-    (components): ActionRow => ({
-      type: ComponentType.ACTION_ROW,
-      components,
-    }),
-  )
-
-/**
- * Helper to create a single column of components
- */
-export const singleColumn = (items: UIComponent[]): ActionRow[] =>
-  items.map((c) => ({
-    type: ComponentType.ACTION_ROW,
-    components: [c],
-  }))
-
-/**
- * Helper to create a button component.
- */
-export const button = (button: Partial<Button>): Button => ({
-  type: ComponentType.BUTTON,
-  style: ButtonStyle.PRIMARY,
-  ...button,
-})
-
-type BasicSelect = Omit<SelectMenu, "type" | "channel_types" | "options">
-
-type StringSelect = BasicSelect & {
-  options: SelectOption[]
-}
-
-type ChannelSelect = Omit<SelectMenu, "type" | "options">
-
-/**
- * Helper to create a select component.
- */
-export const select = (select: StringSelect): SelectMenu => ({
-  type: ComponentType.STRING_SELECT,
-  ...select,
-})
-
-/**
- * Helper to create a select component.
- */
-export const userSelect = (select: BasicSelect): SelectMenu => ({
-  type: ComponentType.USER_SELECT,
-  ...select,
-})
-
-/**
- * Helper to create a select component.
- */
-export const roleSelect = (select: BasicSelect): SelectMenu => ({
-  type: ComponentType.ROLE_SELECT,
-  ...select,
-})
-
-/**
- * Helper to create a select component.
- */
-export const mentionableSelect = (select: BasicSelect): SelectMenu => ({
-  type: ComponentType.MENTIONABLE_SELECT,
-  ...select,
-})
-
-/**
- * Helper to create a select component.
- */
-export const channelSelect = (select: ChannelSelect): SelectMenu => ({
-  type: ComponentType.CHANNEL_SELECT,
-  ...select,
-})
-
-type TextInputOpts = Omit<TextInput, "type" | "style"> & {
-  style?: TextInputStyle
-}
-
-/**
- * Helper to create a text input
- */
-export const textInput = (input: TextInputOpts): TextInput => ({
-  type: ComponentType.TEXT_INPUT,
-  style: TextInputStyle.SHORT,
-  ...input,
-})

package/src/Http/index.ts

@@ -1,65 +0,0 @@
-export class FetchError {
-  readonly _tag = "FetchError"
-  constructor(readonly reason: unknown) {}
-}
-
-export class StatusCodeError {
-  readonly _tag = "StatusCodeError"
-  readonly code: number
-  constructor(readonly response: Response) {
-    this.code = response.status
-  }
-}
-
-export const request = (url: URL | string, init: RequestInit = {}) =>
-  Effect.asyncInterrupt<never, FetchError, Response>((resume) => {
-    const controller = new AbortController()
-    fetch(url, {
-      ...init,
-      signal: controller.signal,
-    })
-      .then((a) => resume(Effect.succeed(a)))
-      .catch((e) => resume(Effect.fail(new FetchError(e))))
-
-    return Either.left(
-      Effect.sync(() => {
-        controller.abort()
-      }),
-    )
-  }).filterOrElseWith(
-    (r) => r.status < 300,
-    (r) => Effect.fail(new StatusCodeError(r)),
-  )
-
-export class JsonParseError {
-  readonly _tag = "JsonParseError"
-  constructor(readonly reason: unknown) {}
-}
-
-export const json = <A = unknown>(r: Response) =>
-  Effect.tryCatchPromise(
-    (): Promise<A> => r.json(),
-    (reason) => new JsonParseError(reason),
-  )
-
-export class BlobError {
-  readonly _tag = "BlobError"
-  constructor(readonly reason: unknown) {}
-}
-
-export const blob = (r: Response) =>
-  Effect.tryCatchPromise(
-    () => r.blob(),
-    (reason) => new BlobError(reason),
-  )
-
-export const requestWithJson = <A = unknown>(
-  url: URL | string,
-  init: RequestInit = {},
-) =>
-  request(url, init).map((response) => ({
-    response,
-    json: json<A>(response),
-    blob: blob(response),
-    text: Effect.promise(() => response.text()),
-  }))

package/src/Interactions/context.ts

@@ -1,100 +0,0 @@
-import { InteractionResponse } from "./definitions.js"
-import { InteractionNotFound } from "./handlers.js"
-import * as Arr from "@fp-ts/data/ReadonlyArray"
-import { optionsMap } from "dfx/Helpers/interactions"
-
-export const InteractionContext = Tag<Discord.Interaction>()
-export const ApplicationCommandContext = Tag<Discord.ApplicationCommandDatum>()
-export const MessageComponentContext = Tag<Discord.MessageComponentDatum>()
-export const ModalSubmitContext = Tag<Discord.ModalSubmitDatum>()
-
-export interface FocusedOptionContext {
-  readonly focusedOption: Discord.ApplicationCommandInteractionDataOption
-}
-export const FocusedOptionContext = Tag<FocusedOptionContext>()
-
-export interface SubCommandContext {
-  readonly command: Discord.ApplicationCommandInteractionDataOption
-}
-export const SubCommandContext = Tag<SubCommandContext>()
-
-export const getCommand = Effect.service(ApplicationCommandContext)
-
-export class ResolvedDataNotFound {
-  readonly _tag = "ResolvedDataNotFound"
-  constructor(
-    readonly data: Discord.ApplicationCommandDatum,
-    readonly name: string,
-  ) {}
-}
-
-export const getResolved = <A>(
-  name: string,
-  f: (id: Discord.Snowflake, data: Discord.ResolvedDatum) => A | undefined,
-) =>
-  Effect.serviceWithEffect(ApplicationCommandContext)((a) =>
-    IxHelpers.resolveOptionValue(
-      name,
-      f,
-    )(a).match(
-      () => Effect.fail(new ResolvedDataNotFound(a, name)),
-      Effect.succeed,
-    ),
-  )
-
-export const focusedOptionValue = Effect.serviceWith(FocusedOptionContext)(
-  (a) => a.focusedOption.value ?? "",
-)
-
-export const commandOptionsMap = Effect.serviceWith(ApplicationCommandContext)(
-  optionsMap,
-)
-
-export const handleSubCommands = <
-  NER extends Record<string, Effect<any, any, Maybe<InteractionResponse>>>,
->(
-  commands: NER,
-): Effect<
-  | Exclude<
-      [NER[keyof NER]] extends [
-        { [EffectTypeId]: { _R: (_: never) => infer R } },
-      ]
-        ? R
-        : never,
-      SubCommandContext
-    >
-  | Discord.Interaction
-  | Discord.ApplicationCommandDatum,
-  [NER[keyof NER]] extends [{ [EffectTypeId]: { _E: (_: never) => infer E } }]
-    ? E
-    : never,
-  Maybe<InteractionResponse>
-> =>
-  Effect.struct({
-    interaction: Effect.service(InteractionContext),
-    data: Effect.service(ApplicationCommandContext),
-  }).flatMap(({ interaction, data }) =>
-    pipe(
-      IxHelpers.allSubCommands(data),
-      Arr.findFirst((a) => !!commands[a.name]),
-      (o) => o.toEither(() => new InteractionNotFound(interaction)),
-      Effect.fromEither,
-      (a) =>
-        a.flatMap((command) =>
-          pipe(
-            commands[command.name],
-            Effect.provideService(SubCommandContext)({ command }),
-          ),
-        ),
-    ),
-  )
-
-export const getSubCommand = Effect.serviceWith(SubCommandContext)(
-  (a) => a.command,
-)
-
-export const subCommandOptionsMap = getSubCommand.map(IxHelpers.optionsMap)
-
-export const modalValues = Effect.serviceWith(ModalSubmitContext)(
-  IxHelpers.componentsMap,
-)

package/src/Interactions/definitions.ts

@@ -1,144 +0,0 @@
-export type InteractionResponse =
-  | {
-      type: Discord.InteractionCallbackType.CHANNEL_MESSAGE_WITH_SOURCE
-      data: Discord.InteractionCallbackMessage
-    }
-  | {
-      type: Discord.InteractionCallbackType.UPDATE_MESSAGE
-      data: Discord.InteractionCallbackMessage
-    }
-  | {
-      type: Discord.InteractionCallbackType.MODAL
-      data: Discord.InteractionCallbackModal
-    }
-  | {
-      type: Discord.InteractionCallbackType.DEFERRED_UPDATE_MESSAGE
-    }
-  | {
-      type: Discord.InteractionCallbackType.DEFERRED_CHANNEL_MESSAGE_WITH_SOURCE
-    }
-  | {
-      type: Discord.InteractionCallbackType.APPLICATION_COMMAND_AUTOCOMPLETE_RESULT
-      data: Discord.InteractionCallbackAutocomplete
-    }
-
-type DescriptionMissing<A> = A extends {
-  type: Exclude<Discord.ApplicationCommandType, 1>
-}
-  ? false
-  : A extends { description: string }
-  ? false
-  : true
-
-export type InteractionDefinition<R, E> =
-  | GlobalApplicationCommand<R, E>
-  | GuildApplicationCommand<R, E>
-  | MessageComponent<R, E>
-  | ModalSubmit<R, E>
-  | Autocomplete<R, E>
-
-export class GlobalApplicationCommand<R, E> {
-  readonly _tag = "GlobalApplicationCommand"
-  constructor(
-    readonly command: Discord.CreateGlobalApplicationCommandParams,
-    readonly handle: Effect<R, E, Maybe<InteractionResponse>>,
-  ) {}
-}
-
-export const global = <
-  R,
-  E,
-  A extends Discord.CreateGlobalApplicationCommandParams,
->(
-  command: A,
-  handle: DescriptionMissing<A> extends true
-    ? "command description is missing"
-    : Effect<R, E, Maybe<InteractionResponse>>,
-) =>
-  new GlobalApplicationCommand<
-    Exclude<R, Discord.Interaction | Discord.ApplicationCommandDatum>,
-    E
-  >(command, handle as any)
-
-export class GuildApplicationCommand<R, E> {
-  readonly _tag = "GuildApplicationCommand"
-  constructor(
-    readonly command: Discord.CreateGuildApplicationCommandParams,
-    readonly handle: Effect<R, E, Maybe<InteractionResponse>>,
-  ) {}
-}
-
-export const guild = <
-  R,
-  E,
-  A extends Discord.CreateGuildApplicationCommandParams,
->(
-  command: A,
-  handle: DescriptionMissing<A> extends true
-    ? "command description is missing"
-    : Effect<R, E, Maybe<InteractionResponse>>,
-) =>
-  new GuildApplicationCommand<
-    Exclude<R, Discord.Interaction | Discord.ApplicationCommandDatum>,
-    E
-  >(command, handle as any)
-
-export class MessageComponent<R, E> {
-  readonly _tag = "MessageComponent"
-  constructor(
-    readonly predicate: (customId: string) => Effect<R, E, boolean>,
-    readonly handle: Effect<R, E, Maybe<InteractionResponse>>,
-  ) {}
-}
-
-export const messageComponent = <R1, R2, E1, E2>(
-  pred: (customId: string) => Effect<R1, E1, boolean>,
-  handle: Effect<R2, E2, Maybe<InteractionResponse>>,
-) =>
-  new MessageComponent<
-    Exclude<R1 | R2, Discord.Interaction | Discord.MessageComponentDatum>,
-    E1 | E2
-  >(pred as any, handle as any)
-
-export class ModalSubmit<R, E> {
-  readonly _tag = "ModalSubmit"
-  constructor(
-    readonly predicate: (customId: string) => Effect<R, E, boolean>,
-    readonly handle: Effect<R, E, Maybe<InteractionResponse>>,
-  ) {}
-}
-
-export const modalSubmit = <R1, R2, E1, E2>(
-  pred: (customId: string) => Effect<R1, E1, boolean>,
-  handle: Effect<R2, E2, Maybe<InteractionResponse>>,
-) =>
-  new ModalSubmit<
-    Exclude<R1 | R2, Discord.Interaction | Discord.ModalSubmitDatum>,
-    E1 | E2
-  >(pred as any, handle as any)
-
-export class Autocomplete<R, E> {
-  readonly _tag = "Autocomplete"
-  constructor(
-    readonly predicate: (
-      focusedOption: Discord.ApplicationCommandInteractionDataOption,
-    ) => Effect<R, E, boolean>,
-    readonly handle: Effect<R, E, Maybe<InteractionResponse>>,
-  ) {}
-}
-
-export const autocomplete = <R1, R2, E1, E2>(
-  pred: (
-    focusedOption: Discord.ApplicationCommandInteractionDataOption,
-  ) => Effect<R1, E1, boolean>,
-  handle: Effect<R2, E2, Maybe<InteractionResponse>>,
-) =>
-  new Autocomplete<
-    Exclude<
-      R1 | R2,
-      | Discord.Interaction
-      | Discord.ApplicationCommandDatum
-      | Discord.ApplicationCommandInteractionDataOption
-    >,
-    E1 | E2
-  >(pred as any, handle as any)