dfx 0.61.5 → 0.61.7

package/src/Helpers/interactions.ts

@@ -24,8 +24,8 @@ export const findSubCommand =
       optionsWithNested(interaction),
       Arr.findFirst(
         o =>
-          o.type === Discord.ApplicationCommandOptionType.SUB_COMMAND
-          && o.name === name,
+          o.type === Discord.ApplicationCommandOptionType.SUB_COMMAND &&
+          o.name === name,
       ),
     )
 
@@ -114,42 +114,46 @@ export const resolved = (data: Discord.Interaction) =>
 /**
  * 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.Interaction): Option.Option<T> =>
-  Option.Do.pipe(
-    Option.bind("data", () =>
-      Option.fromNullable(a.data as Discord.ApplicationCommandDatum)),
-    Option.bind("id", ({ data }) =>
-      Option.flatMapNullable(
-        getOption(name)(data),
-        ({ value }) =>
-          value as Discord.Snowflake,
-      )),
-    Option.bind("r", () => resolved(a)),
-    Option.flatMapNullable(({ id, r }) => f(id, r)),
-  )
+export const resolveOptionValue =
+  <T>(
+    name: string,
+    f: (id: Discord.Snowflake, data: Discord.ResolvedDatum) => T | undefined,
+  ) =>
+  (a: Discord.Interaction): Option.Option<T> =>
+    Option.Do.pipe(
+      Option.bind("data", () =>
+        Option.fromNullable(a.data as Discord.ApplicationCommandDatum),
+      ),
+      Option.bind("id", ({ data }) =>
+        Option.flatMapNullable(
+          getOption(name)(data),
+          ({ value }) => value as Discord.Snowflake,
+        ),
+      ),
+      Option.bind("r", () => resolved(a)),
+      Option.flatMapNullable(({ id, r }) => f(id, r)),
+    )
 
 /**
  * Try find matching option values from the interaction.
  */
-export const resolveValues = <T>(
-  f: (id: Discord.Snowflake, data: Discord.ResolvedDatum) => T | undefined,
-) =>
-(a: Discord.Interaction): Option.Option<ReadonlyArray<T>> =>
-  Option.Do.pipe(
-    Option.bind("values", () =>
-      Option.flatMapNullable(
-        Option.fromNullable(a.data as Discord.MessageComponentDatum),
-        a => a.values as unknown as Array<string>,
-      )),
-    Option.bind("r", () => resolved(a)),
-    Option.map(({ r, values }) =>
-      Arr.compact(values.map(a => Option.fromNullable(f(a as any, r))))
-    ),
-  )
+export const resolveValues =
+  <T>(
+    f: (id: Discord.Snowflake, data: Discord.ResolvedDatum) => T | undefined,
+  ) =>
+  (a: Discord.Interaction): Option.Option<ReadonlyArray<T>> =>
+    Option.Do.pipe(
+      Option.bind("values", () =>
+        Option.flatMapNullable(
+          Option.fromNullable(a.data as Discord.MessageComponentDatum),
+          a => a.values as unknown as Array<string>,
+        ),
+      ),
+      Option.bind("r", () => resolved(a)),
+      Option.map(({ r, values }) =>
+        Arr.compact(values.map(a => Option.fromNullable(f(a as any, r)))),
+      ),
+    )
 
 const extractComponents = (c: Discord.Component): Array<Discord.Component> => {
   if ("components" in c) {
@@ -211,27 +215,26 @@ export const componentValue =
 
 export type InteractionResponse =
   | {
-    type: Discord.InteractionCallbackType.CHANNEL_MESSAGE_WITH_SOURCE
-    data: Discord.InteractionCallbackMessage
-  }
+      type: Discord.InteractionCallbackType.CHANNEL_MESSAGE_WITH_SOURCE
+      data: Discord.InteractionCallbackMessage
+    }
   | {
-    type: Discord.InteractionCallbackType.UPDATE_MESSAGE
-    data: Discord.InteractionCallbackMessage
-  }
+      type: Discord.InteractionCallbackType.UPDATE_MESSAGE
+      data: Discord.InteractionCallbackMessage
+    }
   | {
-    type: Discord.InteractionCallbackType.MODAL
-    data: Discord.InteractionCallbackModal
-  }
+      type: Discord.InteractionCallbackType.MODAL
+      data: Discord.InteractionCallbackModal
+    }
   | {
-    type: Discord.InteractionCallbackType.DEFERRED_UPDATE_MESSAGE
-  }
+      type: Discord.InteractionCallbackType.DEFERRED_UPDATE_MESSAGE
+    }
   | {
-    type: Discord.InteractionCallbackType.DEFERRED_CHANNEL_MESSAGE_WITH_SOURCE
-  }
+      type: Discord.InteractionCallbackType.DEFERRED_CHANNEL_MESSAGE_WITH_SOURCE
+    }
   | {
-    type:
-      Discord.InteractionCallbackType.APPLICATION_COMMAND_AUTOCOMPLETE_RESULT
-    data: Discord.InteractionCallbackAutocomplete
-  }
+      type: Discord.InteractionCallbackType.APPLICATION_COMMAND_AUTOCOMPLETE_RESULT
+      data: Discord.InteractionCallbackAutocomplete
+    }
 
 export const response = (r: InteractionResponse) => r

package/src/Helpers/members.ts

@@ -13,5 +13,5 @@ export const roles =
  * 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")
+  Object.prototype.hasOwnProperty.call(thing, "roles") &&
+  Object.prototype.hasOwnProperty.call(thing, "joined_at")

package/src/Helpers/permissions.ts

@@ -84,8 +84,8 @@ export const forChannel =
     } else {
       const everyone = roles.find(role => role.name === "@everyone")
 
-      basePermissions = BigInt(everyone?.permissions || "0")
-        | BigInt(memberOrRole.permissions)
+      basePermissions =
+        BigInt(everyone?.permissions || "0") | BigInt(memberOrRole.permissions)
       filteredOverwrites = overwrites.filter(
         overwriteIsForRole(guild_id)(memberOrRole),
       )

package/src/Interactions/builder.ts

@@ -8,8 +8,10 @@ import { DiscordREST, type DiscordRESTError } from "dfx/DiscordREST"
 import type * as D from "dfx/Interactions/definitions"
 import type * as Discord from "dfx/types"
 
-type ExtractTag<A> = A extends { _tag: infer Tag } ? Tag extends string ? Tag
-  : never
+type ExtractTag<A> = A extends { _tag: infer Tag }
+  ? Tag extends string
+    ? Tag
+    : never
   : never
 
 /**
@@ -130,17 +132,15 @@ export class InteractionBuilder<R, E, TE> {
       Chunk.map(c => c.command),
     )
 
-    return Effect.flatMap(
-      DiscordREST,
-      rest =>
-        rest.getCurrentBotApplicationInformation().pipe(
-          Effect.flatMap(r => r.json),
-          Effect.flatMap(app =>
-            rest.bulkOverwriteGlobalApplicationCommands(app.id, {
-              body: Http.body.unsafeJson(Chunk.toReadonlyArray(commands)),
-            })
-          ),
+    return Effect.flatMap(DiscordREST, rest =>
+      rest.getCurrentBotApplicationInformation().pipe(
+        Effect.flatMap(r => r.json),
+        Effect.flatMap(app =>
+          rest.bulkOverwriteGlobalApplicationCommands(app.id, {
+            body: Http.body.unsafeJson(Chunk.toReadonlyArray(commands)),
+          }),
         ),
+      ),
     )
   }
 
@@ -154,14 +154,12 @@ export class InteractionBuilder<R, E, TE> {
       Chunk.map(c => c.command),
     )
 
-    return Effect.flatMap(
-      DiscordREST,
-      rest =>
-        rest.bulkOverwriteGuildApplicationCommands(
-          appId,
-          guildId,
-          Chunk.toReadonlyArray(commands) as any,
-        ),
+    return Effect.flatMap(DiscordREST, rest =>
+      rest.bulkOverwriteGuildApplicationCommands(
+        appId,
+        guildId,
+        Chunk.toReadonlyArray(commands) as any,
+      ),
     )
   }
 }

package/src/Interactions/context.ts

@@ -23,7 +23,10 @@ export const SubCommandContext = Tag<SubCommandContext>()
 
 export class ResolvedDataNotFound {
   readonly _tag = "ResolvedDataNotFound"
-  constructor(readonly data: Discord.Interaction, readonly name?: string) {}
+  constructor(
+    readonly data: Discord.Interaction,
+    readonly name?: string,
+  ) {}
 }
 
 export const resolvedValues = <A>(
@@ -33,7 +36,8 @@ export const resolvedValues = <A>(
     Effect.mapError(
       IxHelpers.resolveValues(f)(ix),
       () => new ResolvedDataNotFound(ix),
-    ))
+    ),
+  )
 
 export const resolved = <A>(
   name: string,
@@ -43,7 +47,8 @@ export const resolved = <A>(
     Effect.mapError(
       IxHelpers.resolveOptionValue(name, f)(ix),
       () => new ResolvedDataNotFound(ix, name),
-    ))
+    ),
+  )
 
 export const focusedOptionValue = Effect.map(
   FocusedOptionContext,
@@ -64,18 +69,20 @@ export const handleSubCommands = <
   commands: NER,
 ): Effect.Effect<
   | Exclude<
-    [NER[keyof NER]] extends [
-      { [Effect.EffectTypeId]: { _R: (_: never) => infer R } },
-    ] ? R
-      : never,
-    SubCommandContext
-  >
+      [NER[keyof NER]] extends [
+        { [Effect.EffectTypeId]: { _R: (_: never) => infer R } },
+      ]
+        ? R
+        : never,
+      SubCommandContext
+    >
   | Discord.Interaction
   | Discord.ApplicationCommandDatum,
   | ([NER[keyof NER]] extends [
-    { [Effect.EffectTypeId]: { _E: (_: never) => infer E } },
-  ] ? E
-    : never)
+      { [Effect.EffectTypeId]: { _E: (_: never) => infer E } },
+    ]
+      ? E
+      : never)
   | SubCommandNotFound,
   Discord.InteractionResponse
 > =>
@@ -84,12 +91,12 @@ export const handleSubCommands = <
       Effect.mapError(
         Arr.findFirst(IxHelpers.allSubCommands(data), _ => !!commands[_.name]),
         () => new SubCommandNotFound(data),
-      )
+      ),
     ),
     Effect.flatMap(command =>
       Effect.provideService(commands[command.name], SubCommandContext, {
         command,
-      })
+      }),
     ),
   )
 
@@ -125,10 +132,12 @@ export const optionValue = (name: string) =>
       {
         onNone: () =>
           Effect.flatMap(ApplicationCommand, data =>
-            Effect.fail(new RequiredOptionNotFound(data, name))),
+            Effect.fail(new RequiredOptionNotFound(data, name)),
+          ),
         onSome: Effect.succeed,
       },
-    ))
+    ),
+  )
 
 export const optionValueOptional = (name: string) =>
   Effect.map(
@@ -143,7 +152,10 @@ export const modalValueOption = (name: string) =>
 
 export class ModalValueNotFound {
   readonly _tag = "ModalValueNotFound"
-  constructor(readonly data: Discord.ModalSubmitDatum, readonly name: string) {}
+  constructor(
+    readonly data: Discord.ModalSubmitDatum,
+    readonly name: string,
+  ) {}
 }
 
 export const modalValue = (name: string) =>
@@ -151,4 +163,5 @@ export const modalValue = (name: string) =>
     Effect.mapError(
       IxHelpers.componentValue(name)(data),
       () => new ModalValueNotFound(data, name),
-    ))
+    ),
+  )

package/src/Interactions/definitions.ts

@@ -25,9 +25,8 @@ export class GlobalApplicationCommand<R, E> {
 export const global = <
   R,
   E,
-  const A extends DeepReadonlyObject<
-    Discord.CreateGlobalApplicationCommandParams
-  >,
+  const A extends
+    DeepReadonlyObject<Discord.CreateGlobalApplicationCommandParams>,
 >(
   command: A,
   handle: CommandHandler<R, E, A>,
@@ -48,9 +47,8 @@ export class GuildApplicationCommand<R, E> {
 export const guild = <
   R,
   E,
-  const A extends DeepReadonlyObject<
-    Discord.CreateGuildApplicationCommandParams
-  >,
+  const A extends
+    DeepReadonlyObject<Discord.CreateGuildApplicationCommandParams>,
 >(
   command: A,
   handle: CommandHandler<R, E, A>,
@@ -123,9 +121,12 @@ export const autocomplete = <R1, R2, E1, E2>(
   >(pred as any, handle as any)
 
 // ==== Command handler helpers
-type DeepReadonly<T> = T extends Array<infer R> ? ReadonlyArray<DeepReadonly<R>>
-  : T extends Function ? T
-  : T extends object ? DeepReadonlyObject<T>
+type DeepReadonly<T> = T extends Array<infer R>
+  ? ReadonlyArray<DeepReadonly<R>>
+  : T extends Function
+  ? T
+  : T extends object
+  ? DeepReadonlyObject<T>
   : T
 type DeepReadonlyObject<T> = {
   readonly [P in keyof T]: DeepReadonly<T[P]>
@@ -162,26 +163,29 @@ export interface CommandHelper<A> {
   >
 
   subCommands: <
-    NER extends SubCommandNames<A> extends never ? never
+    NER extends SubCommandNames<A> extends never
+      ? never
       : Record<
-        SubCommandNames<A>,
-        Effect.Effect<any, any, Discord.InteractionResponse>
-      >,
+          SubCommandNames<A>,
+          Effect.Effect<any, any, Discord.InteractionResponse>
+        >,
   >(
     commands: NER,
   ) => Effect.Effect<
     | Exclude<
-      [NER[keyof NER]] extends [
-        { [Effect.EffectTypeId]: { _R: (_: never) => infer R } },
-      ] ? R
-        : never,
-      SubCommandContext
-    >
+        [NER[keyof NER]] extends [
+          { [Effect.EffectTypeId]: { _R: (_: never) => infer R } },
+        ]
+          ? R
+          : never,
+        SubCommandContext
+      >
     | Discord.Interaction
     | Discord.ApplicationCommandDatum,
     [NER[keyof NER]] extends [
       { [Effect.EffectTypeId]: { _E: (_: never) => infer E } },
-    ] ? E
+    ]
+      ? E
       : never,
     Discord.InteractionResponse
   >
@@ -201,9 +205,10 @@ interface CommandOption {
 type SubCommands<A> = A extends {
   readonly type: Discord.ApplicationCommandOptionType.SUB_COMMAND
   readonly options?: ReadonlyArray<CommandOption>
-} ? A
+}
+  ? A
   : A extends { readonly options: ReadonlyArray<CommandOption> }
-    ? SubCommands<A["options"][number]>
+  ? SubCommands<A["options"][number]>
   : never
 
 type SubCommandNames<A> = Option<SubCommands<A>>["name"]
@@ -280,16 +285,20 @@ type SubCommandResolvables<A> = Extract<
 type AllResolvables<A> = Resolvables<A> | SubCommandResolvables<A>
 
 // == Utilities
-type StringLiteral<T> = T extends string ? string extends T ? never
-  : T
+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
+  ? 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>
+}
+  ? Extract<A["options"][number], Option<A["options"][number]> & T>
   : never

package/src/Interactions/gateway.ts

@@ -29,88 +29,90 @@ export interface RunOpts {
 /**
  * @tsplus pipeable dfx/InteractionBuilder runGateway
  */
-export const run = <R, R2, E, TE, E2>(
-  postHandler: (
-    effect: Effect.Effect<
-      R | DiscordREST | Discord.Interaction,
-      TE | DiscordRESTError | DefinitionNotFound,
-      void
-    >,
-  ) => Effect.Effect<R2, E2, void>,
-  { sync = true }: RunOpts = {},
-) =>
-(
-  ix: InteractionBuilder<R, E, TE>,
-): Effect.Effect<
-  DiscordREST | DiscordGateway | Exclude<R2, Discord.Interaction>,
-  E2 | DiscordRESTError | Http.error.ResponseError,
-  never
-> =>
-  Effect.gen(function*(_) {
-    const GlobalApplicationCommand = ix.definitions.pipe(
-      Chunk.map(_ => _[0]),
-      Chunk.filter(
-        (_): _ is GlobalApplicationCommand<R, E> =>
-          _._tag === "GlobalApplicationCommand",
-      ),
-      Chunk.toReadonlyArray,
-    )
-    const GuildApplicationCommand = ix.definitions.pipe(
-      Chunk.map(_ => _[0]),
-      Chunk.filter(
-        (_): _ is GuildApplicationCommand<R, E> =>
-          _._tag === "GuildApplicationCommand",
-      ),
-      Chunk.toReadonlyArray,
-    )
-
-    const gateway = yield* _(DiscordGateway)
-    const rest = yield* _(DiscordREST)
-
-    const application = yield* _(
-      rest.getCurrentBotApplicationInformation(),
-      Effect.flatMap(a => a.json),
-    )
-
-    const globalSync = rest.bulkOverwriteGlobalApplicationCommands(
-      application.id,
-      {
-        body: Http.body.unsafeJson(
-          GlobalApplicationCommand.map(_ => _.command),
+export const run =
+  <R, R2, E, TE, E2>(
+    postHandler: (
+      effect: Effect.Effect<
+        R | DiscordREST | Discord.Interaction,
+        TE | DiscordRESTError | DefinitionNotFound,
+        void
+      >,
+    ) => Effect.Effect<R2, E2, void>,
+    { sync = true }: RunOpts = {},
+  ) =>
+  (
+    ix: InteractionBuilder<R, E, TE>,
+  ): Effect.Effect<
+    DiscordREST | DiscordGateway | Exclude<R2, Discord.Interaction>,
+    E2 | DiscordRESTError | Http.error.ResponseError,
+    never
+  > =>
+    Effect.gen(function* (_) {
+      const GlobalApplicationCommand = ix.definitions.pipe(
+        Chunk.map(_ => _[0]),
+        Chunk.filter(
+          (_): _ is GlobalApplicationCommand<R, E> =>
+            _._tag === "GlobalApplicationCommand",
         ),
-      },
-    )
-
-    const guildSync = GuildApplicationCommand.length
-      ? gateway.handleDispatch("GUILD_CREATE", a =>
-        rest.bulkOverwriteGuildApplicationCommands(
-          application.id,
-          a.id,
-          GuildApplicationCommand.map(_ =>
-            _.command
-          ) as any,
-        ))
-      : Effect.never
-
-    const handle = handlers(ix.definitions, (i, r) =>
-      rest.createInteractionResponse(i.id, i.token, r))
-
-    const run = gateway.handleDispatch("INTERACTION_CREATE", i =>
-      Effect.provideService(postHandler(handle[i.type](i)), Interaction, i))
-
-    return yield* _(
-      sync
-        ? Effect.forever(
-          Effect.all([run, globalSync, guildSync], {
-            concurrency: "unbounded",
-            discard: true,
-          }),
-        )
-        : run,
-    )
-  })
-
-const makeRegistry = Effect.gen(function*(_) {
+        Chunk.toReadonlyArray,
+      )
+      const GuildApplicationCommand = ix.definitions.pipe(
+        Chunk.map(_ => _[0]),
+        Chunk.filter(
+          (_): _ is GuildApplicationCommand<R, E> =>
+            _._tag === "GuildApplicationCommand",
+        ),
+        Chunk.toReadonlyArray,
+      )
+
+      const gateway = yield* _(DiscordGateway)
+      const rest = yield* _(DiscordREST)
+
+      const application = yield* _(
+        rest.getCurrentBotApplicationInformation(),
+        Effect.flatMap(a => a.json),
+      )
+
+      const globalSync = rest.bulkOverwriteGlobalApplicationCommands(
+        application.id,
+        {
+          body: Http.body.unsafeJson(
+            GlobalApplicationCommand.map(_ => _.command),
+          ),
+        },
+      )
+
+      const guildSync = GuildApplicationCommand.length
+        ? gateway.handleDispatch("GUILD_CREATE", a =>
+            rest.bulkOverwriteGuildApplicationCommands(
+              application.id,
+              a.id,
+              GuildApplicationCommand.map(_ => _.command) as any,
+            ),
+          )
+        : Effect.never
+
+      const handle = handlers(ix.definitions, (i, r) =>
+        rest.createInteractionResponse(i.id, i.token, r),
+      )
+
+      const run = gateway.handleDispatch("INTERACTION_CREATE", i =>
+        Effect.provideService(postHandler(handle[i.type](i)), Interaction, i),
+      )
+
+      return yield* _(
+        sync
+          ? Effect.forever(
+              Effect.all([run, globalSync, guildSync], {
+                concurrency: "unbounded",
+                discard: true,
+              }),
+            )
+          : run,
+      )
+    })
+
+const makeRegistry = Effect.gen(function* (_) {
   const ref = yield* _(
     Ref.make(builder as InteractionBuilder<never, never, never>),
   )
@@ -134,7 +136,8 @@ const makeRegistry = Effect.gen(function*(_) {
       Effect.delay(
         pipe(ix, run(Effect.catchAllCause(onError), opts)),
         Duration.seconds(0.1),
-      ))
+      ),
+    )
 
   return { register, run: run_ } as const
 })