Rename D to Discord in many places to improve readablity

tests/Client.test.ts

@@ -1,11 +1,11 @@
-import * as D from 'discord.js'
+import * as Discord from 'discord.js'
 import * as DM from '../src'
 import type {MatchObjectGuild} from './utils'
 import './matchers'
 
 describe('mockClient', () => {
   test('ready event is emitted', async () => {
-    const client = new D.Client({intents: []})
+    const client = new Discord.Client({intents: []})
     const promise = new Promise<void>(resolve => {
       client.on('ready', () => resolve())
     })
@@ -24,9 +24,9 @@ describe('mockClient', () => {
       .addGuildWithBot({id: id2}, {}, app)
 
     test('are emitted with GUILDS intent', async () => {
-      const client = new D.Client({intents: ['GUILDS']})
-      const emittedGuilds = new Promise<ReadonlySet<D.Guild>>(resolve => {
-        const guilds = new Set<D.Guild>()
+      const client = new Discord.Client({intents: ['GUILDS']})
+      const emittedGuilds = new Promise<ReadonlySet<Discord.Guild>>(resolve => {
+        const guilds = new Set<Discord.Guild>()
         client.on('guildCreate', guild => {
           guilds.add(guild)
           if (guilds.size === 2) resolve(guilds)
@@ -42,7 +42,7 @@ describe('mockClient', () => {
     })
 
     test('not emitted without GUILDS intent', async () => {
-      const client = new D.Client({intents: []})
+      const client = new Discord.Client({intents: []})
       const promise = new Promise<void>((resolve, reject) => {
         setTimeout(resolve, 500)
         client.on('guildCreate', ({id}) => {

tests/channels/messages/patch.test.ts

@@ -1,5 +1,5 @@
 import {ChannelType, PermissionFlagsBits} from 'discord-api-types/v9'
-import * as D from 'discord.js'
+import * as Discord from 'discord.js'
 import {guildWithBot, withClient, withClientF} from '../../utils'
 import {getChannel, send} from './utils'
 import type * as DM from '../../../src'
@@ -36,7 +36,7 @@ describe('successes', () => {
     withClientF(async client => {
       const message = await send(client, {
         content: 'foo',
-        embeds: [new D.MessageEmbed({title: 'foo'})]
+        embeds: [new Discord.MessageEmbed({title: 'foo'})]
       })
       const oldEmbeds = message.embeds
       const newContent = 'bar'

tests/channels/messages/post.test.ts

@@ -3,7 +3,7 @@
 */
 
 import {ChannelType} from 'discord-api-types/v9'
-import * as D from 'discord.js'
+import * as Discord from 'discord.js'
 import {guildWithBot, withClient, withClientF} from '../../utils'
 import {getChannel, send} from './utils'
 import type {Snowflake} from 'discord-api-types/v9'
@@ -50,7 +50,7 @@ describe('successes', () => {
   test('basic embed', async () => {
     const title = 'title'
     const description = 'description'
-    const fields: D.EmbedFieldData[] = [
+    const fields: Discord.EmbedFieldData[] = [
       {name: 'field 1', value: 'field 1 value'},
       {name: 'field 2', value: 'field 2 value'}
     ]
@@ -60,7 +60,7 @@ describe('successes', () => {
           (
             await send(client, {embeds: [{title, description, fields}]})
           ).embeds
-        ).toMatchObject<DeepPartialOmit<D.MessageEmbed[]>>([
+        ).toMatchObject<DeepPartialOmit<Discord.MessageEmbed[]>>([
           {title, description, fields}
         ]),
       defaultOpts()
@@ -75,7 +75,7 @@ describe('successes', () => {
       })
       expect(message.attachments.size).toBe(1)
       expect(message.attachments.first()!).toMatchObject<
-        DeepPartialOmit<D.MessageAttachment>
+        DeepPartialOmit<Discord.MessageAttachment>
         // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment -- asymmetric matcher
       >({name, attachment: expect.stringContaining(message.id)})
     }, defaultOpts())
@@ -91,7 +91,7 @@ describe('successes', () => {
     const roleId1 = '20'
     const expectMentions = (
       content: string,
-      allowedMentions: D.MessageMentionOptions | undefined,
+      allowedMentions: Discord.MessageMentionOptions | undefined,
       {
         everyone,
         users,
@@ -116,7 +116,7 @@ describe('successes', () => {
           {roles: [{id: roleId1}]},
           {
             backendOpts: {
-              users: new D.Collection([
+              users: new Discord.Collection([
                 [userId1, {}],
                 [userId2, {}]
               ])

tests/channels/messages/utils.ts

@@ -1,20 +1,20 @@
 import assert from 'assert'
-import type * as D from 'discord.js'
+import type * as Discord from 'discord.js'
 
-export const getChannel = (client: D.Client): D.GuildTextBasedChannel => {
+export const getChannel = (client: Discord.Client): Discord.GuildTextBasedChannel => {
   const guild = client.guilds.cache.first()
   assert(
     guild,
     'There are no cached guilds. Perhaps you forgot to include backend?'
   )
   const channel = guild.channels.cache.find(
-    (chan): chan is D.GuildTextBasedChannel => chan.isText()
+    (chan): chan is Discord.GuildTextBasedChannel => chan.isText()
   )
   assert(channel, 'There are no text channels!')
   return channel
 }
 
 export const send = async (
-  client: D.Client,
-  options: D.MessageOptions | D.MessagePayload | string
-): Promise<D.Message> => getChannel(client).send(options)
+  client: Discord.Client,
+  options: Discord.MessageOptions | Discord.MessagePayload | string
+): Promise<Discord.Message> => getChannel(client).send(options)

tests/guilds.test.ts

@@ -1,4 +1,4 @@
-import * as D from 'discord.js'
+import * as Discord from 'discord.js'
 import * as DM from '../src'
 
 describe('initial guilds', () => {
@@ -8,7 +8,7 @@ describe('initial guilds', () => {
     const backend = new DM.Backend()
     const app = backend.addApplication({bot: {id: userId}})
     backend.addGuildWithBot({id: guildId, owner_id: app.bot.id}, {}, app)
-    const client = new D.Client({intents: ['GUILDS']})
+    const client = new Discord.Client({intents: ['GUILDS']})
     const promise = new Promise<void>(resolve => {
       client.on('guildCreate', async guild => {
         expect(guild.id).toBe(guildId)

tests/guilds/post.test.ts

@@ -3,7 +3,7 @@
 */
 
 import {RESTJSONErrorCodes} from 'discord-api-types/v9'
-import * as D from 'discord.js'
+import * as Discord from 'discord.js'
 import * as DM from '../../src'
 import {withClient, withClientF} from '../utils'
 import type {ChannelTypes} from 'discord.js/typings/enums'
@@ -13,10 +13,10 @@ import '../matchers'
 
 // TODO: fix Discord.js types
 type GuildCreateOpts = Override<
-  D.GuildCreateOptions,
+  Discord.GuildCreateOptions,
   {
     channels?: Override<
-      D.PartialChannelData,
+      Discord.PartialChannelData,
       {type?: keyof typeof ChannelTypes}
     >[]
   }
@@ -50,10 +50,10 @@ describe('successes', () => {
     'overriding basic defaults',
     withClientF(async client => {
       const afkTimeout = 60
-      const defaultMessageNotifications: D.DefaultMessageNotificationLevel =
+      const defaultMessageNotifications: Discord.DefaultMessageNotificationLevel =
         'ONLY_MENTIONS'
-      const explicitContentFilter: D.ExplicitContentFilterLevel = 'ALL_MEMBERS'
-      const verificationLevel: D.VerificationLevel = 'HIGH'
+      const explicitContentFilter: Discord.ExplicitContentFilterLevel = 'ALL_MEMBERS'
+      const verificationLevel: Discord.VerificationLevel = 'HIGH'
       await expect(
         client.guilds.create(name, {
           afkTimeout,
@@ -123,15 +123,15 @@ describe('successes', () => {
       'channel overrides',
       withClientF(async client => {
         const id = 0
-        const deny: D.PermissionString = 'VIEW_CHANNEL'
+        const deny: Discord.PermissionString = 'VIEW_CHANNEL'
         const guild = await client.guilds.create(name, {
           roles: [{}, {id}],
           channels: [{name, permissionOverwrites: [{id, deny}]}]
         })
         const channel = guild.channels.cache.first()!
-        expect(channel).toBeInstanceOf(D.TextChannel)
+        expect(channel).toBeInstanceOf(Discord.TextChannel)
         expect(
-          (channel as D.TextChannel).permissionOverwrites.cache.get(
+          (channel as Discord.TextChannel).permissionOverwrites.cache.get(
             guild.roles.cache.findKey(role => role.id !== guild.id)!
           )?.deny
         ).toEqualBitfield(deny)
@@ -158,7 +158,7 @@ describe('errors', () => {
   // every time otherwise TypeErrors may occur
   // This is why a function is sometimes used to provide the options
   const _formErr = (
-    ...args: Parameters<D.GuildManager['create']>
+    ...args: Parameters<Discord.GuildManager['create']>
   ): (() => Promise<void>) =>
     withClientF(async client =>
       expect(client.guilds.create(...args)).toThrowAPIFormError()

tests/guilds/templates.test.ts

@@ -1,10 +1,10 @@
 import * as DM from '../../src'
 import {guildWithBot, withClient, withClientF} from '../utils'
-import type * as D from 'discord.js'
+import type * as Discord from 'discord.js'
 import type {DeepPartialOmit, MatchObjectGuild} from '../utils'
 import '../matchers'
 
-type MatchObjectTemplate = DeepPartialOmit<D.GuildTemplate, 'valueOf'>
+type MatchObjectTemplate = DeepPartialOmit<Discord.GuildTemplate, 'valueOf'>
 
 const guildId = '0'
 
@@ -118,7 +118,7 @@ describe('create guild template', () => {
   })
 })
 
-const getTemplate = async (client: D.Client): Promise<D.GuildTemplate> =>
+const getTemplate = async (client: Discord.Client): Promise<Discord.GuildTemplate> =>
   (await client.guilds.cache.get(guildId)!.fetchTemplates()).first()!
 
 describe('modify guild template', () => {

tests/matchers.ts

@@ -1,5 +1,5 @@
 import {RESTJSONErrorCodes} from 'discord-api-types/v9'
-import * as D from 'discord.js'
+import * as Discord from 'discord.js'
 import {getMatchers} from 'expect/build/jestMatchersObject'
 import type {SyncExpectationResult} from 'expect/build/types'
 
@@ -18,8 +18,8 @@ declare global {
           : never
       ): R
       toEqualBitfield(
-        ...args: T extends D.BitField<infer S, infer N> | undefined
-          ? [bits: D.BitFieldResolvable<S, N>]
+        ...args: T extends Discord.BitField<infer S, infer N> | undefined
+          ? [bits: Discord.BitFieldResolvable<S, N>]
           : IncompatibleExpectType
       ): R
       toThrowAPIError(
@@ -75,7 +75,7 @@ Received: resolved with ${utils.printReceived(result)}`
     const instanceOfResult = toBeInstanceOf.call(
       context,
       error,
-      D.DiscordAPIError
+      Discord.DiscordAPIError
     )
     if (
       (!instanceOfResult.pass && !isNot) ||
@@ -88,7 +88,7 @@ ${removeMatcherHint(instanceOfResult)}`
       }
     }
 
-    const matchObjectInput: Partial<D.DiscordAPIError> = {code}
+    const matchObjectInput: Partial<Discord.DiscordAPIError> = {code}
     const matchObjectResult = toMatchObject.call(
       context,
       error,
@@ -169,15 +169,15 @@ Received: ${utils.printReceived(received)}`
 
   toEqualBitfield<S extends string, N extends bigint | number>(
     this: jest.MatcherContext,
-    received: D.BitField<S, N> | undefined,
-    bits: D.BitFieldResolvable<S, N>
+    received: Discord.BitField<S, N> | undefined,
+    bits: Discord.BitFieldResolvable<S, N>
   ): jest.CustomMatcherResult {
     const {isNot, promise, utils} = this
     const matcherHint = (): string =>
       `${utils.matcherHint('toEqualBitfield', 'received', 'expected', {
         isNot,
         promise,
-        ...(received instanceof D.Permissions
+        ...(received instanceof Discord.Permissions
           ? {comment: 'Not checking admin'}
           : {})
       })}
@@ -188,7 +188,7 @@ Received: ${utils.printReceived(received)}`
         pass: false,
         message: (): string => `${matcherHint()}
 Expected: ${utils.printExpected(bits)}${
-          bits instanceof D.BitField
+          bits instanceof Discord.BitField
             ? ` (${utils.printExpected(bits.toArray())})`
             : ''
         }

tests/oauth2.test.ts

@@ -1,4 +1,4 @@
-import * as D from 'discord.js'
+import * as Discord from 'discord.js'
 import * as DM from '../src'
 import {expectNotToBeNull, withClient, withClientF} from './utils'
 import './matchers'
@@ -21,10 +21,10 @@ describe('fetchApplication', () => {
       async client => {
         expectNotToBeNull(client.application)
         const application = await client.application.fetch()
-        expect(application).toBeInstanceOf(D.ClientApplication)
+        expect(application).toBeInstanceOf(Discord.ClientApplication)
         expect(application.name).toBe(name)
-        expect(application.owner).toBeInstanceOf(D.User)
-        expect((application.owner as D.User).username).toBe(ownerUsername)
+        expect(application.owner).toBeInstanceOf(Discord.User)
+        expect((application.owner as Discord.User).username).toBe(ownerUsername)
       },
       {
         backend: new DM.Backend({

tests/utils.ts

@@ -1,4 +1,4 @@
-import * as D from 'discord.js'
+import * as Discord from 'discord.js'
 import * as DM from '../src'
 import type {AnyFunction} from '../src/utils'
 
@@ -31,10 +31,10 @@ export type DeepPartialOmit<
 
 // Omitting valueOf because ({...}).valueOf() is Object, whereas
 // (guild as D.Guild).valueOf() is string
-export type MatchObjectGuild = DeepPartialOmit<D.Guild, 'valueOf'>
+export type MatchObjectGuild = DeepPartialOmit<Discord.Guild, 'valueOf'>
 
 export interface WithClientOptions {
-  intents?: D.ClientOptions['intents']
+  intents?: Discord.ClientOptions['intents']
   backend?: DM.Backend
   applicationId?: DM.Snowflake
 }
@@ -57,7 +57,7 @@ export const guildWithBot: (
   return {backend, applicationId: app.id}
 }
 
-const defaultIntents = new D.Intents([
+const defaultIntents = new Discord.Intents([
   'GUILDS',
   'GUILD_MESSAGES',
   'GUILD_MESSAGE_REACTIONS',
@@ -66,11 +66,11 @@ const defaultIntents = new D.Intents([
 ])
 
 export const withClient = <T>(
-  fn: (client: D.Client) => T,
+  fn: (client: Discord.Client) => T,
   {intents = defaultIntents, backend, applicationId}: WithClientOptions = {}
 ): T => fn(new DM.Client({intents}, backend, applicationId))
 
 export const withClientF =
-  <T>(fn: (client: D.Client) => T, options?: WithClientOptions) =>
+  <T>(fn: (client: Discord.Client) => T, options?: WithClientOptions) =>
   (): T =>
     withClient(fn, options)

tests/voice.test.ts

@@ -1,4 +1,4 @@
-import * as D from 'discord.js'
+import * as Discord from 'discord.js'
 import * as DM from '../src'
 import {withClientF} from './utils'
 
@@ -8,7 +8,7 @@ describe('fetchVoiceRegions', () => {
     withClientF(async client => {
       const voiceRegions = await client.fetchVoiceRegions()
       for (const [, region] of voiceRegions)
-        expect(region).toBeInstanceOf(D.VoiceRegion)
+        expect(region).toBeInstanceOf(Discord.VoiceRegion)
     })
   )
 
@@ -18,7 +18,7 @@ describe('fetchVoiceRegions', () => {
       async client => {
         const voiceRegions = await client.fetchVoiceRegions()
         for (const [, region] of voiceRegions)
-          expect(region).toBeInstanceOf(D.VoiceRegion)
+          expect(region).toBeInstanceOf(Discord.VoiceRegion)
         expect(voiceRegions.get('id1')?.name).toBe('name 1')
         expect(voiceRegions.get('id2')?.name).toBe('name 2')
       },

types/WebSocketShard.d.ts

@@ -1,8 +1,8 @@
-import type * as D from 'discord.js'
+import type * as Discord from 'discord.js'
 
 // constructor is private
 declare const WebSocketShard: new (
-  manager: D.WebSocketManager,
+  manager: Discord.WebSocketManager,
   id: number
-) => D.WebSocketShard
+) => Discord.WebSocketShard
 export = WebSocketShard