WingetCord

# Install from npm
npm install @wingetcord/wingetcord

# Or install latest from GitHub
npm install github:wingetcord/WingetCord

{
  "compilerOptions": {
    "target": "ES2022",
    "module": "NodeNext",
    "strict": true,
    "experimentalDecorators": true,
    "emitDecoratorMetadata": true
  }
}

import { Client, Intents } from '@wingetcord/wingetcord';

const client = new Client({
  token: 'YOUR_BOT_TOKEN',
  intents: ['GUILDS', 'GUILD_MESSAGES', 'MESSAGE_CONTENT']
});

client.onReady((user) => {
  console.log(`🚀 Logged in as ${user.tag}`);
});

client.onMessage(async (msg) => {
  if (msg.content === '!ping') {
    await msg.reply('🏓 Pong!');
  }
});

client.login();

import { Client, IntentBits } from '@wingetcord/wingetcord';

const client = new Client({
  token: process.env.DISCORD_TOKEN,
  intents: [
    IntentBits.GUILDS,
    IntentBits.GUILD_MESSAGES,
    IntentBits.MESSAGE_CONTENT
  ]
});

await client.login();

await client.say('123456789', 'Hello, World!');
await client.say('123456789', { embeds: [embed], components: [] });

const health = client.pulse();
// Returns: { status, ping, uptime, memory, guilds }

import { Command, CommandContext } from '@wingetcord/wingetcord';

class PingCommand extends Command {
  options = {
    name: 'ping',
    description: 'Responds with pong',
    aliases: ['p'],
    cooldown: 5000,
    permissions: ['SendMessages']
  };

  async execute(ctx: CommandContext) {
    await ctx.message.reply('🏓 Pong!');
  }
}

client.commands.register(new PingCommand());

class ReadyEvent extends Event {
  name = 'READY';
  once = true;
  execute() { console.log('Bot is ready!'); }
}
client.events.register(new ReadyEvent());

await client.handler.setup({
  commands:     './src/commands',
  events:       './src/events',
  interactions: './src/interactions'
});

client.onMessage((msg) => { /* MESSAGE_CREATE */ });
client.onInteraction((i) => { /* INTERACTION_CREATE */ });
client.onReady((user) => { /* READY */ });

client.use(async (ctx, next) => {
  const start = Date.now();
  await next();
  console.log(`[${ctx.event}] ${Date.now() - start}ms`);
});

const col = new Collection<string, User>();
col.find(u => u.bot);    col.filter(u => u.bot);
col.map(u => u.tag);     col.some(u => u.bot);
col.every(u => !u.bot);  col.random();   col.first();

const perms = new PermissionsBitField('SendMessages');
perms.has('SendMessages');     // true
perms.add('ManageMessages');
perms.remove('SendMessages');
perms.toJSON();

const embed = new EmbedBuilder()
  .setTitle('Hello World')
  .setDescription('This is an embed')
  .setColor('#6366f1')
  .addField('Field 1', 'Value 1', true)
  .setTimestamp()
  .setFooter('Footer text', 'https://example.com/icon.png');

const button = new ButtonBuilder()
  .setCustomId('my-btn')
  .setLabel('Click Me')
  .setStyle(ButtonStyle.Primary)
  .setEmoji({ name: '👋' })
  .onAction(async (i) => { await i.reply('Clicked!'); });

const select = new SelectMenuBuilder()
  .setCustomId('my-select')
  .setPlaceholder('Select an option')
  .addOptions(
    { label: 'Option 1', value: 'option1' },
    { label: 'Option 2', value: 'option2' }
  )
  .onAction(async (i) => { await i.reply(`Selected: ${i.values}`); });

const modal = new ModalBuilder()
  .setTitle('Feedback Form')
  .setCustomId('feedback-modal')
  .addComponents(
    new TextInputBuilder()
      .setLabel('Name').setCustomId('name')
      .setStyle(TextInputStyle.Short).setRequired(true),
    new TextInputBuilder()
      .setLabel('Feedback').setCustomId('feedback')
      .setStyle(TextInputStyle.Paragraph)
  );
await interaction.showModal(modal);

const row = new ActionRowBuilder().addComponents(button, select);
await channel.send({ content: 'Choose:', components: [row] });

const store = new ReactiveStore({ count: 0 });
store.state.count = 5;

store.on('change', ({ property, oldValue, newValue }) => {
  console.log(`${property}: ${oldValue} → ${newValue}`);
});
store.on('change:count', ({ newValue }) => console.log(newValue));

const collector = client.interactions.createCollector({
  filter: (i) => i.customId === 'verify',
  max: 10, time: 60000
});
collector.on('collect', (i) => console.log(i.id));
collector.on('end', (collected, reason) => console.log(reason));

@Command({ name: 'ban', description: 'Ban a user' })
@Permissions('BAN_MEMBERS')
@Cooldown(1000)
@Option('user', { description: 'User to ban', required: true })
export class BanCommand {
  async execute(ctx: CommandContext) {
    const user = ctx.getUser('user');
  }
}

@Once('ready')
export class ReadyHandler {
  execute() { console.log('Ready!'); }
}

Color.resolve('#FF5733');       // hex string
Color.resolve(0xFF5733);        // hex number
Color.resolve([255, 87, 51]);   // RGB array
Color.resolve('random');        // random color
Color.toHex(16737203);          // → "#FF5733"
Color.toRGB(16737203);          // → [255, 87, 51]

import {
  Client, IntentBits, EmbedBuilder,
  ButtonBuilder, ButtonStyle, ActionRowBuilder
} from '@wingetcord/wingetcord';

const client = new Client({
  token: process.env.DISCORD_TOKEN,
  intents: [IntentBits.GUILDS, IntentBits.GUILD_MESSAGES, IntentBits.MESSAGE_CONTENT]
});

client.use(async (ctx, next) => {
  console.log(`[${ctx.event}]`); await next();
});

client.onReady((user) => console.log(`🚀 ${user.tag}`));

client.onMessage(async (msg) => {
  if (msg.content === '!help') {
    const embed = new EmbedBuilder()
      .setTitle('📖 Help')
      .setDescription('Available: !ping, !stats, !help')
      .setColor('#6366f1');

    const btn = new ButtonBuilder()
      .setLabel('Ping').setStyle(ButtonStyle.Primary)
      .setCustomId('ping')
      .onAction(async (i) => await i.reply('Pong!'));

    await msg.reply({
      embeds: [embed],
      components: [new ActionRowBuilder().addComponents(btn)]
    });
  }
  if (msg.content === '!ping')
    await msg.reply(`🏓 Pong! (${client.gateway.ping}ms)`);
});

client.interactions.on('command', async (i) => {
  if (i.commandName === 'stats') {
    const h = client.pulse();
    await i.reply({ embeds: [{
      title: '📊 Stats',
      fields: [
        { name: 'Ping',   value: `${h.ping}ms`,            inline: true },
        { name: 'Uptime', value: `${Math.floor(h.uptime)}s`, inline: true },
        { name: 'Guilds', value: `${h.guilds}`,             inline: true }
      ]
    }]});
  }
});

client.login();

npm install          # Install dependencies
npm run build        # Compile TypeScript
npm run dev          # Run in development
npm run typecheck    # Type checking only
npm run clean        # Clean dist output