dfx 1.0.5 → 1.0.7

package/dist/src/Helpers/interactions.ts

@@ -1,317 +0,0 @@
-import * as Discord from "../types.ts"
-import * as Arr from "effect/Array"
-import { identity, pipe } from "effect/Function"
-import * as HashMap from "effect/HashMap"
-import * as Option from "effect/Option"
-
-/**
- * Option find a sub-command within the interaction options.
- */
-export const allSubCommands = (
-  interaction: Discord.APIApplicationCommandInteraction["data"],
-) =>
-  pipe(
-    optionsWithNested(interaction as any),
-    Arr.filter(
-      o => o.type === Discord.ApplicationCommandOptionType.SUB_COMMAND,
-    ),
-  )
-
-/**
- * Get the target for the application command data.
- */
-export const target = (
-  interaction: Discord.APIApplicationCommandInteraction["data"],
-):
-  | Discord.APIApplicationCommandInteraction["data"]
-  | Discord.UserResponse
-  | Discord.MessageResponse => targetTypes[interaction.type](interaction)
-
-const targetTypes: Record<
-  Discord.ApplicationCommandType,
-  (
-    data: any,
-  ) =>
-    | Discord.UserResponse
-    | Discord.MessageResponse
-    | Discord.APIApplicationCommandInteraction["data"]
-> = {
-  [Discord.ApplicationCommandType.USER]: data =>
-    data.resolved.users![(data as any).target_id] as Discord.UserResponse,
-  [Discord.ApplicationCommandType.MESSAGE]: data =>
-    data.resolved.messages![data.target_id],
-  [Discord.ApplicationCommandType.CHAT]: data => data,
-  [Discord.ApplicationCommandType.PRIMARY_ENTRY_POINT]: data => data,
-}
-
-/**
- * Option find a sub-command within the interaction options.
- */
-export const findSubCommand =
-  (name: string) =>
-  (interaction: Discord.APIApplicationCommandInteraction["data"]) =>
-    pipe(
-      optionsWithNested(interaction as any),
-      Arr.findFirst(
-        (
-          o,
-        ): o is Discord.APIApplicationCommandInteractionDataSubcommandOption =>
-          o.type === Discord.ApplicationCommandOptionType.SUB_COMMAND &&
-          o.name === name,
-      ),
-    )
-
-/**
- * If the sub-command exists return `true`, else `false`.
- */
-export const isSubCommand =
-  (name: string) => (_: Discord.APIApplicationCommandInteraction["data"]) =>
-    Option.isSome(findSubCommand(name)(_))
-
-/**
- * Option get the options for a sub-command
- */
-export const subCommandOptions =
-  (name: string) => (_: Discord.APIApplicationCommandInteraction["data"]) =>
-    Option.flatMapNullishOr(findSubCommand(name)(_), o => o.options)
-
-/**
- * A lens for accessing nested options in a interaction.
- */
-export const optionsWithNested = (data: {
-  readonly options?:
-    | ReadonlyArray<Discord.APIApplicationCommandInteractionDataOption>
-    | undefined
-}): Array<Discord.APIApplicationCommandInteractionDataOption> => {
-  const optsFromOption = (opt: {
-    readonly options?: ReadonlyArray<Discord.APIApplicationCommandInteractionDataOption>
-  }): Array<Discord.APIApplicationCommandInteractionDataOption> =>
-    Option.fromNullishOr(opt.options).pipe(
-      Option.map(opts => [
-        ...opts,
-        ...opts.flatMap(_ => optsFromOption(_ as any)),
-      ]),
-      Option.match({ onNone: () => [], onSome: identity }),
-    )
-
-  return Option.fromNullishOr(data.options).pipe(
-    Option.map(opts => [
-      ...opts,
-      ...opts.flatMap(_ => optsFromOption(_ as any)),
-    ]),
-    Option.getOrElse(() => []),
-  )
-}
-
-/**
- * Return the interaction options as a name / value map.
- */
-export const transformOptions = (
-  options: Array<Discord.APIApplicationCommandInteractionDataOption>,
-) =>
-  options.reduce(
-    (map, option) => HashMap.set(map, option.name, (option as any).value),
-    HashMap.empty<string, string | number | boolean | undefined>(),
-  )
-
-/**
- * Return the interaction options as a name / value map.
- */
-export const optionsMap = (data: {
-  readonly options?:
-    | ReadonlyArray<Discord.APIApplicationCommandInteractionDataOption>
-    | undefined
-}) => transformOptions(optionsWithNested(data))
-
-/**
- * Try find a matching option from the interaction.
- */
-export const getOption =
-  (name: string) =>
-  (data: {
-    readonly options?:
-      | ReadonlyArray<Discord.APIApplicationCommandInteractionDataOption>
-      | undefined
-  }) =>
-    Arr.findFirst(optionsWithNested(data), o => o.name === name)
-
-/**
- * Try find a matching option from the interaction.
- */
-export const focusedOption = (data: {
-  readonly options?:
-    | ReadonlyArray<Discord.APIApplicationCommandInteractionDataOption>
-    | undefined
-}) =>
-  Arr.findFirst(
-    optionsWithNested(data),
-    o => "focused" in o && o.focused === true,
-  )
-
-/**
- * Try find a matching option value from the interaction.
- */
-export const optionValue =
-  (name: string) =>
-  (data: {
-    readonly options?:
-      | ReadonlyArray<Discord.APIApplicationCommandInteractionDataOption>
-      | undefined
-  }) =>
-    Option.flatMapNullishOr(getOption(name)(data), o =>
-      "value" in o ? o.value : undefined,
-    )
-
-/**
- * Try extract resolved data
- */
-export const resolved = (data: Discord.APIInteraction) =>
-  Option.flatMapNullishOr(Option.fromNullishOr(data.data), a =>
-    "resolved" in a
-      ? (a.resolved as Discord.InteractionDataResolved)
-      : undefined,
-  )
-
-/**
- * Try find a matching option value from the interaction.
- */
-export const resolveOptionValue =
-  <T>(
-    name: string,
-    f: (
-      id: Discord.Snowflake,
-      data: Discord.InteractionDataResolved,
-    ) => T | undefined,
-  ) =>
-  (a: Discord.APIInteraction): Option.Option<T> =>
-    Option.Do.pipe(
-      Option.bind("data", () => Option.fromNullishOr(a.data as any)),
-      Option.bind("id", ({ data }) =>
-        Option.flatMapNullishOr(
-          getOption(name)(data) as Option.Option<{ value: Discord.Snowflake }>,
-          ({ value }) => value,
-        ),
-      ),
-      Option.bind("r", () => resolved(a)),
-      Option.flatMapNullishOr(({ id, r }) => f(id, r)),
-    )
-
-/**
- * Try find matching option values from the interaction.
- */
-export const resolveValues =
-  <T>(
-    f: (
-      id: Discord.Snowflake,
-      data: Discord.InteractionDataResolved,
-    ) => T | undefined,
-  ) =>
-  (a: Discord.APIInteraction): Option.Option<ReadonlyArray<T>> =>
-    Option.Do.pipe(
-      Option.bind("values", () =>
-        Option.flatMapNullishOr(
-          Option.fromNullishOr(a.data as any),
-          data => data.values as unknown as Array<string>,
-        ),
-      ),
-      Option.bind("r", () => resolved(a)),
-      Option.map(({ r, values }) =>
-        Arr.getSomes(
-          values.map(value => Option.fromNullishOr(f(value as any, r))),
-        ),
-      ),
-    )
-
-const extractComponents = (
-  c: Discord.AllComponents,
-): Array<Discord.AllComponents> => {
-  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.APIModalSubmission,
-): Array<Discord.AllComponents> => [
-  ...(a.components as any),
-  ...a.components.flatMap(extractComponents as any),
-]
-
-/**
- * A lens for accessing the components in a interaction.
- */
-export const componentsWithValue = (data: Discord.APIModalSubmission) =>
-  Arr.filter(components(data), c => "value" in c && c.value !== undefined)
-
-/**
- * Return the interaction components as an id / value map.
- */
-export const transformComponents = (options: Array<Discord.AllComponents>) =>
-  (options as Array<Discord.TextInputComponentResponse>).reduce(
-    (map, c) => (c.custom_id ? HashMap.set(map, c.custom_id, c.value) : map),
-    HashMap.empty<string, string | undefined | null>(),
-  )
-
-/**
- * Return the interaction components as an id / value map.
- */
-export const componentsMap = (data: Discord.APIModalSubmission) =>
-  transformComponents(components(data))
-
-/**
- * Try find a matching component from the interaction.
- */
-export const getComponent =
-  (id: string) => (data: Discord.APIModalSubmission) =>
-    Arr.findFirst(
-      components(data),
-      o => (o as Discord.TextInputComponentResponse).custom_id === id,
-    )
-
-/**
- * Try find a matching component value from the interaction.
- */
-export const componentValue =
-  (id: string) => (data: Discord.APIModalSubmission) =>
-    Option.flatMapNullishOr(
-      getComponent(id)(data),
-      o => (o as Discord.TextInputComponentResponse).value,
-    )
-
-export type InteractionResponse =
-  | {
-      type: typeof Discord.InteractionCallbackTypes.CHANNEL_MESSAGE_WITH_SOURCE
-      data: Discord.IncomingWebhookInteractionRequest
-      files?: ReadonlyArray<File>
-    }
-  | {
-      type: typeof Discord.InteractionCallbackTypes.UPDATE_MESSAGE
-      data: Discord.IncomingWebhookUpdateForInteractionCallbackRequestPartial
-      files?: ReadonlyArray<File>
-    }
-  | {
-      type: typeof Discord.InteractionCallbackTypes.MODAL
-      data: Discord.ModalInteractionCallbackRequestData
-    }
-  | {
-      type: typeof Discord.InteractionCallbackTypes.DEFERRED_UPDATE_MESSAGE
-    }
-  | {
-      type: typeof Discord.InteractionCallbackTypes.DEFERRED_CHANNEL_MESSAGE_WITH_SOURCE
-    }
-  | {
-      type: typeof Discord.InteractionCallbackTypes.APPLICATION_COMMAND_AUTOCOMPLETE_RESULT
-      data: Discord.ApplicationCommandAutocompleteCallbackRequest["data"]
-    }
-  | {
-      type: typeof Discord.InteractionCallbackTypes.LAUNCH_ACTIVITY
-    }
-
-export const response = (
-  r: InteractionResponse,
-): Discord.CreateInteractionResponseRequest => r

package/dist/src/Helpers/members.ts

@@ -1,18 +0,0 @@
-import type * as Discord from "../types.ts"
-
-/**
- * From a list of roles, filter out the ones the guild member has.
- */
-export const roles =
-  (guildRoles: Array<Discord.GuildRoleResponse>) =>
-  (member: Discord.GuildMemberResponse) =>
-    guildRoles.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.GuildMemberResponse =>
-  Object.prototype.hasOwnProperty.call(thing, "roles") &&
-  Object.prototype.hasOwnProperty.call(thing, "joined_at")

package/dist/src/Helpers/permissions.ts

@@ -1,145 +0,0 @@
-import { pipe } from "effect/Function"
-import * as Effect from "effect/Effect"
-import * as Flags from "./flags.ts"
-import * as Members from "./members.ts"
-import * as Discord from "../types.ts"
-
-/**
- * A constant of all the permissions
- */
-export const ALL = Flags.all(Discord.Permissions)
-
-/**
- * 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.Permissions)
-
-/**
- * Convert a list of flag names to a bitfield.
- */
-export const fromList = Flags.fromListBigint(Discord.Permissions)
-
-/**
- * Reduce a list of roles to a bitfield of all the permissions added together.
- */
-export const forRoles = (roles: Array<Discord.GuildRoleResponse>) =>
-  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: Array<Discord.GuildRoleResponse>) =>
-  (member: Discord.GuildMemberResponse) =>
-    pipe(Members.roles(roles)(member), forRoles)
-
-const overwriteIsForMember =
-  (guildId?: string) =>
-  (member: Discord.GuildMemberResponse) =>
-  (overwrite: Discord.ChannelPermissionOverwriteResponse) => {
-    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.GuildRoleResponse) =>
-  (overwrite: Discord.ChannelPermissionOverwriteResponse) => {
-    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: Array<Discord.GuildRoleResponse>) =>
-  ({ guild_id, permission_overwrites }: Discord.GuildChannelResponse) =>
-  (memberOrRole: Discord.GuildMemberResponse | Discord.GuildRoleResponse) => {
-    const overwrites = permission_overwrites || []
-    const hasAdmin = has(Discord.Permissions.Administrator)
-    let basePermissions: bigint
-    let filteredOverwrites: Array<Discord.ChannelPermissionOverwriteResponse>
-
-    if (Members.is(memberOrRole)) {
-      if ((memberOrRole as any).permissions)
-        return BigInt((memberOrRole as any).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: ReadonlyArray<Discord.ChannelPermissionOverwriteResponse>) =>
-    overwrites.reduce(
-      (current, overwrite) =>
-        (current & ~BigInt(overwrite.deny)) | BigInt(overwrite.allow),
-      permissions,
-    )
-
-interface RolesCache<E> {
-  getForParent: (
-    parentId: string,
-  ) => Effect.Effect<ReadonlyMap<string, Discord.GuildRoleResponse>, E>
-}
-
-export const hasInChannel =
-  <E>(rolesCache: RolesCache<E>, permission: bigint) =>
-  (
-    channel: Discord.GuildChannelResponse,
-    memberOrRole: Discord.GuildMemberResponse | Discord.GuildRoleResponse,
-  ) =>
-    Effect.map(rolesCache.getForParent(channel.guild_id!), roles => {
-      const channelPerms = forChannel([...roles.values()])(channel)(
-        memberOrRole,
-      )
-      return has(permission)(channelPerms)
-    })
-
-export const hasInGuild =
-  <E>(rolesCache: RolesCache<E>, permission: bigint) =>
-  (guildId: Discord.Snowflake, member: Discord.GuildMemberResponse) =>
-    Effect.map(rolesCache.getForParent(guildId), roles => {
-      const hasPerm = has(permission)
-
-      return member.roles.some(id => {
-        const role = roles.get(id)
-        return role ? hasPerm(role.permissions) : false
-      })
-    })