dfx 0.110.1 → 0.111.0

package/src/Interactions/definitions.ts

@@ -1,4 +1,3 @@
-import type * as Option from "effect/Option"
 import type * as Effect from "effect/Effect"
 import type {
   DiscordApplicationCommand,
@@ -6,11 +5,10 @@ import type {
   DiscordInteraction,
   DiscordMessageComponent,
   DiscordModalSubmit,
-  SubCommandContext,
 } from "dfx/Interactions/context"
 import type * as Discord from "dfx/types"
-import type { NoSuchElementException } from "effect/Cause"
 import type { Scope } from "effect/Scope"
+import type { CommandHelper } from "./commandHelper"
 
 export type InteractionDefinition<R, E> =
   | GlobalApplicationCommand<R, E>
@@ -129,169 +127,6 @@ export type CommandHandler<R, E, A = any> =
   | Effect.Effect<Discord.InteractionResponse, E, R>
   | CommandHandlerFn<R, E, A>
 
-export interface CommandHelper<A> {
-  resolve: <T>(
-    name: AllResolvables<A>["name"],
-    f: (id: Discord.Snowflake, data: Discord.ResolvedDatum) => T | undefined,
-  ) => Effect.Effect<T, NoSuchElementException, DiscordInteraction>
-
-  option: (
-    name: AllCommandOptions<A>["name"],
-  ) => Effect.Effect<
-    Option.Option<Discord.ApplicationCommandInteractionDataOption>,
-    never,
-    DiscordApplicationCommand
-  >
-
-  optionValue: <N extends AllRequiredCommandOptions<A>["name"]>(
-    name: N,
-  ) => Effect.Effect<CommandValue<A, N>, never, DiscordApplicationCommand>
-
-  optionValueOptional: <N extends AllCommandOptions<A>["name"]>(
-    name: N,
-  ) => Effect.Effect<
-    Option.Option<CommandValue<A, N>>,
-    never,
-    DiscordApplicationCommand
-  >
-
-  subCommands: <
-    NER extends SubCommandNames<A> extends never
-      ? never
-      : Record<
-          SubCommandNames<A>,
-          Effect.Effect<Discord.InteractionResponse, any, any>
-        >,
-  >(
-    commands: NER,
-  ) => Effect.Effect<
-    Discord.InteractionResponse,
-    [NER[keyof NER]] extends [
-      { [Effect.EffectTypeId]: { _E: (_: never) => infer E } },
-    ]
-      ? E
-      : never,
-    | Exclude<
-        [NER[keyof NER]] extends [
-          { [Effect.EffectTypeId]: { _R: (_: never) => infer R } },
-        ]
-          ? R
-          : never,
-        SubCommandContext
-      >
-    | DiscordInteraction
-    | DiscordApplicationCommand
-  >
-}
-
 export type CommandHandlerFn<R, E, A> = (
   i: CommandHelper<A>,
 ) => Effect.Effect<Discord.InteractionResponse, E, R>
-
-interface CommandOption {
-  readonly type: any
-  readonly name: string
-  readonly options?: ReadonlyArray<CommandOption>
-}
-
-// == Sub commands
-type SubCommands<A> = A extends {
-  readonly type: 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,
-  | Discord.ApplicationCommandOptionType.SUB_COMMAND
-  | 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 =
-  | Discord.ApplicationCommandOptionType.ROLE
-  | Discord.ApplicationCommandOptionType.USER
-  | Discord.ApplicationCommandOptionType.MENTIONABLE
-  | 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

package/src/Interactions/utils.ts

@@ -1,9 +1,9 @@
 import * as Chunk from "effect/Chunk"
 import * as Effect from "effect/Effect"
-import * as Ctx from "dfx/Interactions/context"
 import type * as D from "dfx/Interactions/definitions"
 import type * as Discord from "dfx/types"
 import * as Array from "effect/Array"
+import { CommandHelper } from "./commandHelper"
 
 export type DefinitionFlattened<R, E, TE, A> =
   D.InteractionDefinition<R, E> extends infer D
@@ -19,14 +19,6 @@ export type DefinitionFlattenedCommand<R, E, TE, A> = Extract<
   { _tag: "GlobalApplicationCommand" | "GuildApplicationCommand" }
 >
 
-const context: D.CommandHelper<any> = {
-  resolve: Ctx.resolved,
-  option: Ctx.option,
-  optionValue: Ctx.optionValue,
-  optionValueOptional: Ctx.optionValueOptional,
-  subCommands: Ctx.handleSubCommands,
-} as any
-
 export const flattenDefinitions = <R, E, TE, A, B>(
   definitions: Chunk.Chunk<
     readonly [
@@ -59,7 +51,7 @@ export const flattenDefinitions = <R, E, TE, A, B>(
                   definition.handle as (
                     _: any,
                   ) => Effect.Effect<Discord.InteractionResponse>
-                )(context),
+                )(new CommandHelper(i)),
                 _ => handleResponse(i, _),
               ),
             ),

package/src/version.ts

@@ -1 +1 @@
-export const LIB_VERSION = "0.110.1";
+export const LIB_VERSION = "0.111.0";

package/version.d.ts

@@ -1,2 +1,2 @@
-export declare const LIB_VERSION = "0.110.1";
+export declare const LIB_VERSION = "0.111.0";
 //# sourceMappingURL=version.d.ts.map

package/version.js

@@ -4,5 +4,5 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.LIB_VERSION = void 0;
-const LIB_VERSION = exports.LIB_VERSION = "0.110.1";
+const LIB_VERSION = exports.LIB_VERSION = "0.111.0";
 //# sourceMappingURL=version.js.map