djs-next 0.0.1

package/src/templates/ts.ts

@@ -0,0 +1,53 @@
+export const tsTemplates = {
+  index: `import { DJSNextClient, GatewayIntentBits } from 'djs-next';
+import 'dotenv/config';
+
+const client = new DJSNextClient({
+  intents: [GatewayIntentBits.Guilds, GatewayIntentBits.GuildMessages],
+  commandsDir: './src/commands',
+  eventsDir: './src/events',
+  componentsDir: './src/components',
+  tasksDir: './src/tasks',
+  clientId: process.env.CLIENT_ID
+});
+
+client.start(process.env.DISCORD_TOKEN!);
+`,
+
+  ping: `import { FileCommand } from 'djs-next';
+
+export default {
+  description: 'Replies with the actual bot latency!',
+  execute: async (interaction, client) => {
+    const sent = await interaction.reply({ content: 'Pinging...', withResponse: true });
+    const msg = sent.resource?.message || await interaction.fetchReply();
+    await interaction.editReply(\`Pong! 🏓\\nWebsocket Latency: \\\`\${client.ws.ping}ms\\\`\\nAPI Latency: \\\`\${msg.createdTimestamp - interaction.createdTimestamp}ms\\\`\`);
+  },
+  executeText: async (message, args, client) => {
+    const sent = await message.reply('Pinging...');
+    await sent.edit(\`Pong! 🏓\\nWebsocket Latency: \\\`\${client.ws.ping}ms\\\`\\nAPI Latency: \\\`\${sent.createdTimestamp - message.createdTimestamp}ms\\\`\`);
+  }
+} as FileCommand;
+`,
+
+  ready: `import { DJSNextEvent, Events } from 'djs-next';
+
+export const event: DJSNextEvent<Events.ClientReady> = {
+  name: Events.ClientReady,
+  once: true,
+  execute: (client) => {
+    console.log('Ready! Logged in as ' + client.user?.tag);
+  }
+};
+`,
+
+  healthcheck: `import { FileTask } from 'djs-next';
+
+export const task: FileTask = {
+  interval: 60000,
+  execute: async (client) => {
+    console.log('[Task] Healthcheck completed.');
+  }
+};
+`
+};

package/src/test/client.test.ts

@@ -0,0 +1,8 @@
+import { DJSNextClient } from '../client.js';
+
+describe('DJSNextClient', () => {
+  it('should instantiate without throwing', () => {
+    const client = new DJSNextClient({ intents: [] });
+    expect(client).toBeDefined();
+  });
+});

package/src/types.ts

@@ -0,0 +1,94 @@
+import {
+  ClientOptions,
+  ClientEvents,
+  ChatInputCommandInteraction,
+  Client,
+  ApplicationCommandOptionData,
+  PermissionResolvable,
+  AutocompleteInteraction,
+  MessageComponentInteraction,
+  ModalSubmitInteraction,
+  Interaction,
+  Message
+} from 'discord.js';
+
+export interface CooldownAdapter {
+  get(commandId: string, userId: string): Promise<number | null> | number | null;
+  set(commandId: string, userId: string, expirationTime: number): Promise<void> | void;
+}
+
+export interface DJSNextConfig {
+  devGuildId?: string;
+  errorLogChannelId?: string;
+  responses?: {
+    developerOnly?: string | null;
+    guildOnly?: string | null;
+    cooldown?: string | null;
+    missingPerms?: string | null;
+    errorBoundary?: string | null;
+  };
+  locales?: string[];
+  defaultLocale?: string;
+  directories?: {
+    commands?: string;
+    events?: string;
+    components?: string;
+    tasks?: string;
+    locales?: string;
+  };
+  cooldownAdapter?: CooldownAdapter;
+}
+
+export interface DJSNextClientOptions extends ClientOptions {
+  commandsDir?: string;
+  eventsDir?: string;
+  componentsDir?: string;
+  tasksDir?: string;
+  clientId?: string;
+  guildId?: string;
+  developers?: string[];
+  prefixes?: string[] | string;
+  enableSlashCommands?: boolean;
+  enableTextCommands?: boolean;
+  enableMentionPrefix?: boolean | string[];
+  enableNoPrefix?: boolean | string[];
+  middleware?: (interaction: Interaction | Message, client: Client) => Promise<boolean> | boolean;
+  config?: DJSNextConfig;
+  db?: any;
+}
+
+export interface FileTask<DB = any> {
+  filepath?: string;
+  interval: number;
+  execute: (client: Client & { db: DB; t: Function; config: DJSNextConfig }) => Promise<void> | void;
+}
+
+export interface FileCommand<DB = any> {
+  filepath?: string;
+  description: string;
+  options?: ApplicationCommandOptionData[];
+  cooldown?: number;
+  userPermissions?: PermissionResolvable[];
+  botPermissions?: PermissionResolvable[];
+  developerOnly?: boolean;
+  guildOnly?: boolean;
+  aliases?: string[];
+  preconditions?: string[];
+  execute?: (interaction: ChatInputCommandInteraction, client: Client & { db: DB; t: Function; config: DJSNextConfig }) => Promise<void> | void;
+  executeText?: (message: Message, args: string[], client: Client & { db: DB; t: Function; config: DJSNextConfig }) => Promise<void> | void;
+  autocomplete?: (interaction: AutocompleteInteraction, client: Client & { db: DB; t: Function; config: DJSNextConfig }) => Promise<void> | void;
+}
+
+export interface FileComponent<DB = any> {
+  filepath?: string;
+  customId?: string;
+  preconditions?: string[];
+  execute: (interaction: MessageComponentInteraction | ModalSubmitInteraction, client: Client & { db: DB; t: Function; config: DJSNextConfig }, params?: Record<string, string>) => Promise<void> | void;
+}
+
+export interface Event<K extends keyof ClientEvents = keyof ClientEvents, DB = any> {
+  filepath?: string;
+  name: K;
+  once?: boolean;
+  execute: (client: Client & { db: DB; t: Function; config: DJSNextConfig }, ...args: ClientEvents[K]) => Promise<void> | void;
+}

package/src/utils/PaginationBuilder.ts

@@ -0,0 +1,94 @@
+import { 
+  ActionRowBuilder, 
+  ButtonBuilder, 
+  ButtonStyle, 
+  CommandInteraction, 
+  EmbedBuilder, 
+  Message, 
+  ComponentType 
+} from 'discord.js';
+
+export class PaginationBuilder {
+  private pages: EmbedBuilder[] = [];
+  private timeout: number = 60000;
+
+  constructor(pages?: EmbedBuilder[]) {
+    if (pages) this.pages = pages;
+  }
+
+  public addPage(embed: EmbedBuilder): this {
+    this.pages.push(embed);
+    return this;
+  }
+
+  public setPages(pages: EmbedBuilder[]): this {
+    this.pages = pages;
+    return this;
+  }
+
+  public setTimeout(ms: number): this {
+    this.timeout = ms;
+    return this;
+  }
+
+  public async build(target: CommandInteraction | Message): Promise<Message | null> {
+    if (this.pages.length === 0) throw new Error('[djs-next] PaginationBuilder requires at least one page.');
+
+    if (this.pages.length === 1) {
+      if (target instanceof CommandInteraction) {
+        if (target.deferred || target.replied) {
+          return await target.editReply({ embeds: [this.pages[0]] }) as Message;
+        }
+        return await target.reply({ embeds: [this.pages[0]], fetchReply: true }) as Message;
+      } else {
+        return await target.reply({ embeds: [this.pages[0]] });
+      }
+    }
+
+    let currentPage = 0;
+
+    const row = new ActionRowBuilder<ButtonBuilder>().addComponents(
+      new ButtonBuilder().setCustomId('prev').setLabel('◀').setStyle(ButtonStyle.Primary).setDisabled(true),
+      new ButtonBuilder().setCustomId('page').setLabel(`1 / ${this.pages.length}`).setStyle(ButtonStyle.Secondary).setDisabled(true),
+      new ButtonBuilder().setCustomId('next').setLabel('▶').setStyle(ButtonStyle.Primary)
+    );
+
+    let replyMsg: Message;
+    if (target instanceof CommandInteraction) {
+      if (target.deferred || target.replied) {
+        replyMsg = await target.editReply({ embeds: [this.pages[0]], components: [row] }) as Message;
+      } else {
+        replyMsg = await target.reply({ embeds: [this.pages[0]], components: [row], fetchReply: true }) as Message;
+      }
+    } else {
+      replyMsg = await target.reply({ embeds: [this.pages[0]], components: [row] });
+    }
+
+    const userId = target instanceof CommandInteraction ? target.user.id : target.author.id;
+
+    const collector = replyMsg.createMessageComponentCollector({
+      componentType: ComponentType.Button,
+      time: this.timeout,
+      filter: i => i.user.id === userId
+    });
+
+    collector.on('collect', async i => {
+      if (i.customId === 'prev') currentPage--;
+      else if (i.customId === 'next') currentPage++;
+
+      const newRow = new ActionRowBuilder<ButtonBuilder>().addComponents(
+        new ButtonBuilder().setCustomId('prev').setLabel('◀').setStyle(ButtonStyle.Primary).setDisabled(currentPage === 0),
+        new ButtonBuilder().setCustomId('page').setLabel(`${currentPage + 1} / ${this.pages.length}`).setStyle(ButtonStyle.Secondary).setDisabled(true),
+        new ButtonBuilder().setCustomId('next').setLabel('▶').setStyle(ButtonStyle.Primary).setDisabled(currentPage === this.pages.length - 1)
+      );
+
+      await i.update({ embeds: [this.pages[currentPage]], components: [newRow] });
+    });
+
+    collector.on('end', () => {
+      replyMsg.edit({ components: [] }).catch(() => null);
+    });
+
+    return replyMsg;
+  }
+}

package/src/utils/configLoader.ts

@@ -0,0 +1,27 @@
+import path from 'path';
+import fs from 'fs';
+import { pathToFileURL } from 'url';
+import { DJSNextConfig } from '../types.js';
+
+export async function loadConfig(): Promise<DJSNextConfig> {
+  const exts = ['.js', '.mjs', '.cjs', '.ts', '.mts', '.cts'];
+  const cwd = process.cwd();
+  
+  for (const ext of exts) {
+    const configPath = path.join(cwd, `djs-next.config${ext}`);
+    if (fs.existsSync(configPath)) {
+      try {
+        const configModule = await import(pathToFileURL(configPath).href);
+        return configModule.default || configModule;
+      } catch (err) {
+        console.error(`[djs-next] Error loading config file ${configPath}:`, err);
+        return {};
+      }
+    }
+  }
+  return {};
+}
+
+export function defineConfig(config: DJSNextConfig): DJSNextConfig {
+  return config;
+}

package/src/utils/i18n.ts

@@ -0,0 +1,57 @@
+import fs from 'fs';
+import path from 'path';
+
+let localesCache: Record<string, Record<string, any>> = {};
+let defaultLoc = 'en';
+
+export function loadLocales(localesDir: string, defaultLocale?: string) {
+  if (defaultLocale) defaultLoc = defaultLocale;
+  
+  if (!fs.existsSync(localesDir)) return;
+
+  const files = fs.readdirSync(localesDir);
+  for (const file of files) {
+    if (file.endsWith('.json')) {
+      const lang = file.replace('.json', '');
+      const content = fs.readFileSync(path.join(localesDir, file), 'utf8');
+      try {
+        localesCache[lang] = JSON.parse(content);
+      } catch (e) {
+        console.error(`[djs-next] Failed to parse locale file: ${file}`, e);
+      }
+    }
+  }
+}
+
+export function translate(key: string, locale: string = defaultLoc, variables?: Record<string, string | number>): string {
+  // Fallback to default locale if the requested one is not found
+  const dict = localesCache[locale] || localesCache[defaultLoc] || {};
+  
+  const keys = key.split('.');
+  let value: any = dict;
+
+  for (const k of keys) {
+    if (value && typeof value === 'object') {
+      value = value[k];
+    } else {
+      value = undefined;
+      break;
+    }
+  }
+
+  if (typeof value !== 'string') {
+    return key; // return the key itself if string not found
+  }
+
+  if (variables) {
+    for (const [varKey, varValue] of Object.entries(variables)) {
+      value = value.replace(new RegExp(`{{s*${varKey}s*}}`, 'g'), String(varValue));
+    }
+  }
+
+  return value;
+}
+
+export function getLocalesCache() {
+  return localesCache;
+}

package/src/utils/paginate.ts

@@ -0,0 +1,90 @@
+import {
+  ActionRowBuilder,
+  ButtonBuilder,
+  ButtonStyle,
+  CommandInteraction,
+  EmbedBuilder,
+  Message,
+  MessageComponentInteraction
+} from 'discord.js';
+
+export async function paginate(
+  context: Message | CommandInteraction | MessageComponentInteraction,
+  pages: EmbedBuilder[],
+  time: number = 60000
+) {
+  const isMessage = 'author' in context;
+
+  if (!isMessage) {
+    if (!context.deferred && !context.replied) {
+      await context.deferReply();
+    }
+  }
+
+  if (pages.length === 1) {
+    if (isMessage) {
+      return context.reply({ embeds: [pages[0]], components: [] });
+    } else {
+      return context.editReply({ embeds: [pages[0]], components: [] });
+    }
+  }
+
+  let index = 0;
+
+  const prevButton = new ButtonBuilder()
+    .setCustomId('djs_prev')
+    .setLabel('Previous')
+    .setStyle(ButtonStyle.Primary)
+    .setDisabled(true);
+
+  const nextButton = new ButtonBuilder()
+    .setCustomId('djs_next')
+    .setLabel('Next')
+    .setStyle(ButtonStyle.Primary);
+
+  const row = new ActionRowBuilder<ButtonBuilder>().addComponents(prevButton, nextButton);
+
+  let message: Message;
+  if (isMessage) {
+    message = await context.reply({
+      embeds: [pages[index]],
+      components: [row],
+    });
+  } else {
+    message = await context.editReply({
+      embeds: [pages[index]],
+      components: [row],
+    });
+  }
+
+  const collector = message.createMessageComponentCollector({
+    filter: (i) => i.user.id === (isMessage ? context.author.id : context.user.id),
+    time
+  });
+
+  collector.on('collect', async (i: MessageComponentInteraction) => {
+    if (i.customId === 'djs_prev') {
+      index = index > 0 ? index - 1 : index;
+    } else if (i.customId === 'djs_next') {
+      index = index < pages.length - 1 ? index + 1 : index;
+    }
+
+    prevButton.setDisabled(index === 0);
+    nextButton.setDisabled(index === pages.length - 1);
+
+    await i.update({
+      embeds: [pages[index]],
+      components: [new ActionRowBuilder<ButtonBuilder>().addComponents(prevButton, nextButton)]
+    });
+  });
+
+  collector.on('end', async () => {
+    prevButton.setDisabled(true);
+    nextButton.setDisabled(true);
+    if (message.editable) {
+      await message.edit({
+        components: [new ActionRowBuilder<ButtonBuilder>().addComponents(prevButton, nextButton)]
+      }).catch(() => {});
+    }
+  });
+}

package/src/utils/prompts.ts

@@ -0,0 +1,76 @@
+import {
+  ActionRowBuilder,
+  ButtonBuilder,
+  ButtonStyle,
+  CommandInteraction,
+  EmbedBuilder,
+  Message,
+  MessageComponentInteraction
+} from 'discord.js';
+
+/**
+ * Sends a confirmation prompt (Yes/No) to the user.
+ * @param context The message or interaction context.
+ * @param content The text or embed to display in the prompt.
+ * @param time Time to wait for a response in milliseconds.
+ * @returns Boolean indicating true for Yes, false for No, or null if timed out.
+ */
+export async function confirmPrompt(
+  context: Message | CommandInteraction | MessageComponentInteraction,
+  content: string | EmbedBuilder,
+  time: number = 30000
+): Promise<boolean | null> {
+  const isMessage = 'author' in context;
+
+  if (!isMessage) {
+    if (!context.deferred && !context.replied) {
+      await context.deferReply();
+    }
+  }
+
+  const yesButton = new ButtonBuilder()
+    .setCustomId('djs_prompt_yes')
+    .setLabel('Yes')
+    .setStyle(ButtonStyle.Success);
+
+  const noButton = new ButtonBuilder()
+    .setCustomId('djs_prompt_no')
+    .setLabel('No')
+    .setStyle(ButtonStyle.Danger);
+
+  const row = new ActionRowBuilder<ButtonBuilder>().addComponents(yesButton, noButton);
+
+  const payload: any = { components: [row] };
+  if (typeof content === 'string') {
+    payload.content = content;
+  } else {
+    payload.embeds = [content];
+  }
+
+  let message: Message;
+  if (isMessage) {
+    message = await context.reply(payload);
+  } else {
+    message = await context.editReply(payload);
+  }
+
+  try {
+    const interaction = await message.awaitMessageComponent({
+      filter: (i) => i.user.id === (isMessage ? context.author.id : context.user.id),
+      time
+    });
+
+    if (interaction.customId === 'djs_prompt_yes') {
+      await interaction.update({ components: [] });
+      return true;
+    } else {
+      await interaction.update({ components: [] });
+      return false;
+    }
+  } catch (error) {
+    if (message.editable) {
+      await message.edit({ components: [] }).catch(() => {});
+    }
+    return null; // Timed out
+  }
+}

package/test_payload.js

@@ -0,0 +1,3 @@
+const { MessagePayload, Message } = require('discord.js');
+const payload = MessagePayload.create({ flags: { bitfield: 0 } }, "Pong!");
+console.log(payload.resolveBody());

package/test_reply.js

@@ -0,0 +1,4 @@
+const { Client, MessagePayload } = require('discord.js');
+const client = new Client({ intents: [] });
+const payload = MessagePayload.create(client, { components: [], flags: 32768 });
+console.log(payload.resolveBody());

package/tsconfig.json

@@ -0,0 +1,16 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "declaration": true,
+    "outDir": "./dist",
+    "types": ["node"],
+    "ignoreDeprecations": "6.0"
+  },
+  "include": ["src/**/*"]
+}

package/tsup.config.ts

@@ -0,0 +1,10 @@
+import { defineConfig } from 'tsup';
+
+export default defineConfig({
+  entry: ['src/index.ts'],
+  format: ['cjs', 'esm'], // Build for CommonJS and ES Modules
+  dts: true, // Generate declaration file (.d.ts)
+  splitting: false,
+  sourcemap: true,
+  clean: true,
+});