@mostfeatured/dbi 0.0.9 → 0.0.12

package/package.json

@@ -3,13 +3,13 @@
     "@discordjs/rest": "^1.0.1",
     "discord-api-types": "^0.37.0",
     "discord-hybrid-sharding": "^1.7.4",
-    "discord.js": "^14.1.2",
+    "discord.js": "^14.3.0",
     "lodash": "^4.17.21",
     "snakecase-keys": "^5.4.2",
     "stuffs": "^0.1.17"
   },
   "name": "@mostfeatured/dbi",
-  "version": "0.0.9",
+  "version": "0.0.12",
   "main": "dist/index.js",
   "type": "commonjs",
   "private": false,

package/src/DBI.ts

@@ -15,28 +15,36 @@ import { hookEventListeners } from "./methods/hookEventListeners";
 import eventMap from "./data/eventMap.json";
 import { DBIModal, TDBIModalOmitted } from "./types/Modal";
 import * as Sharding from "discord-hybrid-sharding";
+import _ from "lodash";
+import { DBIInteractionLocale, TDBIInteractionLocaleOmitted } from "./types/InteractionLocale";
+
+export interface DBIStore {
+  get(key: string, defaultValue?: any): Promise<any>;
+  set(key: string, value: any): Promise<void>;
+  delete(key: string): Promise<void>;
+  has(key: string): Promise<boolean>;
+}
 
 export interface DBIConfig {
   discord: {
     token: string;
-    options?: Discord.ClientOptions
+    options: Discord.ClientOptions
   }
-  defaults?: {
-    locale?: TDBILocaleString,
-    directMessages?: boolean,
-    defaultMemberPermissions?: Discord.PermissionsString[]
+  defaults: {
+    locale: TDBILocaleString,
+    directMessages: boolean,
+    defaultMemberPermissions: Discord.PermissionsString[]
   };
 
-  sharding?: boolean;
-
-  store?: {
-    get(key: string, defaultValue?: any): Promise<any>;
-    set(key: string, value: any): Promise<void>;
-    del(key: string): Promise<void>;
-    has(key: string): Promise<boolean>;
-  }
+  sharding: boolean;
+  /**
+   * Persist store. (Default to MemoryStore thats not persis tho.)
+   */
+  store: DBIStore;
 }
 
+export type TDBIConfigConstructor = Partial<DBIConfig>;
+
 export interface DBIRegisterAPI {
   ChatInput(cfg: TDBIChatInputOmitted): DBIChatInput;
   ChatInputOptions: typeof DBIChatInputOptions;
@@ -46,11 +54,12 @@ export interface DBIRegisterAPI {
   SelectMenu(cfg: TDBISelectMenuOmitted): DBISelectMenu;
   MessageContextMenu(cfg: TDBIMessageContextMenuOmitted): DBIMessageContextMenu;
   UserContextMenu(cfg: TDBIUserContextMenuOmitted): DBIUserContextMenu;
+  InteractionLocale(cfg: TDBIInteractionLocaleOmitted): DBIInteractionLocale;
   Modal(cfg: TDBIModalOmitted): DBIModal;
-  onUnload(cb: ()=>Promise<any>);
+  onUnload(cb: () => Promise<any> | any): any;
 }
 
-export class DBI {
+export class DBI<TOtherData = Record<string, any>> {
   namespace: string;
   config: DBIConfig;
   client: Discord.Client<true>;
@@ -59,7 +68,8 @@ export class DBI {
     events: Discord.Collection<string, DBIEvent>;
     plugins: Discord.Collection<string, any>;
     locales: Discord.Collection<string, DBILocale>;
-    other: Record<string, any>;
+    interactionLocales: Discord.Collection<string, DBIInteractionLocale>;
+    other: TOtherData;
     eventMap: Record<string, string[]>;
     unloaders: Set<() => void>;
     registers: Set<(...args: any[]) => any>;
@@ -69,7 +79,7 @@ export class DBI {
   events: Events;
   cluster?: Sharding.Client;
   private _loaded: boolean;
-  constructor(namespace: string, config: DBIConfig) {
+  constructor(namespace: string, config: TDBIConfigConstructor) {
     this.namespace = namespace;
 
     config.store = config.store as any || new MemoryStore();
@@ -79,7 +89,9 @@ export class DBI {
       directMessages: false,
       ...(config.defaults || {})
     };
+    config.sharding = config.sharding ?? false;
 
+    // @ts-ignore
     this.config = config;
 
     this.data = {
@@ -87,7 +99,8 @@ export class DBI {
       events: new Discord.Collection(),
       plugins: new Discord.Collection(),
       locales: new Discord.Collection(),
-      other: {},
+      interactionLocales: new Discord.Collection(),
+      other: {} as TOtherData,
       eventMap,
       unloaders: new Set(),
       registers: new Set(),
@@ -103,7 +116,7 @@ export class DBI {
         shardCount: (Sharding as any).data.TOTAL_SHARDS
       } : {})
     });
-    this.cluster = config.sharding ? new Sharding.Client(this.client) : null;
+    this.cluster = config.sharding ? new Sharding.Client(this.client) : undefined;
     this._hookListeners();
     this._loaded = false;
   }
@@ -128,11 +141,11 @@ export class DBI {
     for await (const cb of this.data.registers) {
       let ChatInput = function(cfg: DBIChatInput) {
         let dbiChatInput = new DBIChatInput(self, cfg);
-        if (self.data.interactions.has(dbiChatInput.name)) throw new Error(`DBIChatInput "${dbiChatInput.name}" already loaded as "${self.data.interactions.get(dbiChatInput.name).type}"!`);
+        if (self.data.interactions.has(dbiChatInput.name)) throw new Error(`DBIChatInput "${dbiChatInput.name}" already loaded as "${self.data.interactions.get(dbiChatInput.name)?.type}"!`);
         self.data.interactions.set(dbiChatInput.name, dbiChatInput);
         return dbiChatInput;
       };
-      ChatInput = Object.assign(ChatInput, class { constructor(...args) { return ChatInput.call(this, ...args); } });
+      ChatInput = Object.assign(ChatInput, class { constructor(...args: any[]) { return ChatInput.apply(this, args as any); } });
 
       let Event = function(cfg: TDBIEventOmitted) {
         let dbiEvent = new DBIEvent(self, cfg);
@@ -140,48 +153,47 @@ export class DBI {
         self.data.events.set(dbiEvent.name, dbiEvent);
         return dbiEvent;
       };
-      Event = Object.assign(Event, class { constructor(...args) { return Event.call(this, ...args); } });
+      Event = Object.assign(Event, class { constructor(...args: any[]) { return Event.apply(this, args as any); } });
 
       let Button = function(cfg: TDBIButtonOmitted) {
         let dbiButton = new DBIButton(self, cfg);
-        if (self.data.interactions.has(dbiButton.name)) throw new Error(`DBIButton "${dbiButton.name}" already loaded as "${self.data.interactions.get(dbiButton.name).type}"!`);
+        if (self.data.interactions.has(dbiButton.name)) throw new Error(`DBIButton "${dbiButton.name}" already loaded as "${self.data.interactions.get(dbiButton.name)?.type}"!`);
         self.data.interactions.set(dbiButton.name, dbiButton);
         return dbiButton;
       };
-      Button = Object.assign(Button, class { constructor(...args) { return Button.call(this, ...args); } });
+      Button = Object.assign(Button, class { constructor(...args: any[]) { return Button.apply(this, args as any); } });
 
       let SelectMenu = function(cfg: TDBISelectMenuOmitted) {
         let dbiSelectMenu = new DBISelectMenu(self, cfg);
-        if (self.data.interactions.has(dbiSelectMenu.name)) throw new Error(`DBISelectMenu "${dbiSelectMenu.name}" already loaded as "${self.data.interactions.get(dbiSelectMenu.name).type}"!`);
+        if (self.data.interactions.has(dbiSelectMenu.name)) throw new Error(`DBISelectMenu "${dbiSelectMenu.name}" already loaded as "${self.data.interactions.get(dbiSelectMenu.name)?.type}"!`);
         self.data.interactions.set(dbiSelectMenu.name, dbiSelectMenu);
         return dbiSelectMenu;
       };
-      SelectMenu = Object.assign(SelectMenu, class { constructor(...args) { return SelectMenu.call(this, ...args); } });
+      SelectMenu = Object.assign(SelectMenu, class { constructor(...args: any[]) { return SelectMenu.apply(this, args as any); } });
 
       let MessageContextMenu = function(cfg: TDBIMessageContextMenuOmitted) {
         let dbiMessageContextMenu = new DBIMessageContextMenu(self, cfg);
-        if (self.data.interactions.has(dbiMessageContextMenu.name)) throw new Error(`DBIMessageContextMenu "${dbiMessageContextMenu.name}" already loaded as "${self.data.interactions.get(dbiMessageContextMenu.name).type}"!`);
+        if (self.data.interactions.has(dbiMessageContextMenu.name)) throw new Error(`DBIMessageContextMenu "${dbiMessageContextMenu.name}" already loaded as "${self.data.interactions.get(dbiMessageContextMenu.name)?.type}"!`);
         self.data.interactions.set(dbiMessageContextMenu.name, dbiMessageContextMenu);
         return dbiMessageContextMenu;
       };
-      MessageContextMenu = Object.assign(MessageContextMenu, class { constructor(...args) { return MessageContextMenu.call(this, ...args); } });
+      MessageContextMenu = Object.assign(MessageContextMenu, class { constructor(...args: any[]) { return MessageContextMenu.apply(this, args as any); } });
 
       let UserContextMenu = function(cfg: TDBIUserContextMenuOmitted) {
         let dbiUserContextMenu = new DBIUserContextMenu(self, cfg);
-        if (self.data.interactions.has(dbiUserContextMenu.name)) throw new Error(`DBIUserContextMenu "${dbiUserContextMenu.name}" already loaded as "${self.data.interactions.get(dbiUserContextMenu.name).type}"!`);
+        if (self.data.interactions.has(dbiUserContextMenu.name)) throw new Error(`DBIUserContextMenu "${dbiUserContextMenu.name}" already loaded as "${self.data.interactions.get(dbiUserContextMenu.name)?.type}"!`);
         self.data.interactions.set(dbiUserContextMenu.name, dbiUserContextMenu);
         return dbiUserContextMenu;
       };
-      UserContextMenu = Object.assign(UserContextMenu, class { constructor(...args) { return UserContextMenu.call(this, ...args); } });
+      UserContextMenu = Object.assign(UserContextMenu, class { constructor(...args: any[]) { return UserContextMenu.apply(this, args as any); } });
 
       let Modal = function(cfg: TDBIModalOmitted) {
         let dbiModal = new DBIModal(self, cfg);
-        if (self.data.interactions.has(dbiModal.name)) throw new Error(`DBIModal "${dbiModal.name}" already loaded as "${self.data.interactions.get(dbiModal.name).type}"!`);
+        if (self.data.interactions.has(dbiModal.name)) throw new Error(`DBIModal "${dbiModal.name}" already loaded as "${self.data.interactions.get(dbiModal.name)?.type}"!`);
         self.data.interactions.set(dbiModal.name, dbiModal);
         return dbiModal;
       };
-      Modal = Object.assign(Modal, class { constructor(...args) { return Modal.call(this, ...args); } });
-
+      Modal = Object.assign(Modal, class { constructor(...args: any[]) { return Modal.apply(this, args as any); } });
 
       let Locale = function(cfg: TDBILocaleConstructor) {
         let dbiLocale = new DBILocale(self, cfg);
@@ -189,7 +201,15 @@ export class DBI {
         self.data.locales.set(dbiLocale.name, dbiLocale);
         return dbiLocale;
       };
-      Locale = Object.assign(Locale, class { constructor(...args) { return Locale.call(this, ...args); } });
+      Locale = Object.assign(Locale, class { constructor(...args: any[]) { return Locale.apply(this, args as any); } });
+
+      let InteractionLocale = function(cfg: TDBIInteractionLocaleOmitted) {
+        let dbiInteractionLocale = new DBIInteractionLocale(self, cfg);
+        if (self.data.interactionLocales.has(dbiInteractionLocale.name)) throw new Error(`DBIInteractionLocale "${dbiInteractionLocale.name}" already loaded!`);
+        self.data.interactionLocales.set(dbiInteractionLocale.name, dbiInteractionLocale);
+        return dbiInteractionLocale;
+      };
+      InteractionLocale = Object.assign(InteractionLocale, class { constructor(...args: any[]) { return InteractionLocale.apply(this, args as any); } });
 
       await cb({
         ChatInput,
@@ -201,13 +221,46 @@ export class DBI {
         MessageContextMenu,
         UserContextMenu,
         Modal,
-        onUnload(cb) {
+        InteractionLocale,
+        onUnload(cb: ()=> Promise<any> | any) {
           self.data.registerUnloaders.add(cb);
         },
       });
     }
   }
 
+  /**
+   * Shorthands for modifying `dbi.data.other`
+   */
+  get<K extends keyof TOtherData>(k: K, defaultValue?: TOtherData[K]): TOtherData[K] {
+    if (this.has(k as any)) {
+      this.set(k, defaultValue);
+      return defaultValue;
+    }
+    return _.get(this.data.other, k);
+  }
+
+  /**
+   * Shorthands for modifying `dbi.data.other`
+   */
+  set<K extends keyof TOtherData>(k: K, v: TOtherData[K]): any {
+    this.data.other = _.set(this.data.other as any, k, v);
+  }
+
+  /**
+   * Shorthands for modifying `dbi.data.other`
+   */
+  has(k: string): boolean {
+    return _.has(this.data.other, k as any);
+  }
+
+  /**
+   * Shorthands for modifying `dbi.data.other`
+   */
+  delete(k: string): boolean {
+    return _.unset(this.data.other, k);
+  }
+
   async login(): Promise<any> {
     await this.client.login(this.config.discord.token);
   }
@@ -237,13 +290,14 @@ export class DBI {
   async publish(type: "Global", clear?: boolean): Promise<any>;
   async publish(type: "Guild", guildId: string, clear?: boolean): Promise<any>;
 
-  async publish(...args) {
+  async publish(...args: any[]) {
     let interactions = this.data.interactions.filter(i => i.type == "ChatInput" || i.type == "MessageContextMenu" || i.type == "UserContextMenu") as any;
     switch (args[0]) {
       case "Global": {
         return await publishInteractions(
           this.config.discord.token,
           args[1] ? new Discord.Collection() : interactions,
+          this.data.interactionLocales,
           args[0]
         );
       }
@@ -251,6 +305,7 @@ export class DBI {
         return await publishInteractions(
           this.config.discord.token,
           args[2] ? new Discord.Collection() : interactions,
+          this.data.interactionLocales,
           args[0],
           args[1]
         );

package/src/index.ts

@@ -1,7 +1,7 @@
-import { DBI, DBIConfig } from "./DBI";
+import { DBI, TDBIConfigConstructor } from "./DBI";
 export { recursiveImport } from "./utils/recursiveImport";
 export { MemoryStore } from "./utils/MemoryStore";
 
-export function createDBI(namespace: string, cfg: DBIConfig): DBI {
-  return new DBI(namespace, cfg);
+export function createDBI<TOtherType = Record<string, any>>(namespace: string, cfg: TDBIConfigConstructor): DBI<TOtherType> {
+  return new DBI<TOtherType>(namespace, cfg);
 }

package/src/methods/hookInteractionListeners.ts

@@ -25,7 +25,7 @@ export function hookInteractionListeners(dbi: DBI): () => any {
           (
             (i.type == "Button" || i.type == "SelectMenu" || i.type == "Modal")
             && isUsesCustomId
-            && parsedId.name == i.name
+            && parsedId?.name == i.name
           )
         )
       });
@@ -68,10 +68,11 @@ export function hookInteractionListeners(dbi: DBI): () => any {
     }
 
     for (const type in rateLimitKeyMap) {
-      let key = `RateLimit:${rateLimitKeyMap[type]}`;
+      // @ts-ignore
+      let key = `RateLimit["${rateLimitKeyMap[type]}"]`;
       let val = await dbi.config.store.get(key);
       if (val && Date.now() > val.at + val.duration) {
-        await dbi.config.store.del(key);
+        await dbi.config.store.delete(key);
         val = null;
       }
       if (val) {
@@ -90,7 +91,8 @@ export function hookInteractionListeners(dbi: DBI): () => any {
     }
 
     async function setRateLimit(type: string, duration: number) {
-      await dbi.config.store.set(`RateLimit:${rateLimitKeyMap[type]}`, { at: Date.now(), duration });
+      // @ts-ignore
+      await dbi.config.store.set(`RateLimit["${rateLimitKeyMap[type]}"]`, { at: Date.now(), duration });
     }
 
     let other = {};
@@ -101,8 +103,10 @@ export function hookInteractionListeners(dbi: DBI): () => any {
       dbi,
       // @ts-ignore
       interaction: inter as any,
+      // @ts-ignore
       locale,
       setRateLimit,
+      // @ts-ignore
       data,
       other
     });

package/src/methods/publishInteractions.ts

@@ -4,12 +4,16 @@ import { REST } from "@discordjs/rest";
 import { Routes, RESTGetAPIUserResult, RESTPutAPIApplicationCommandsJSONBody, ApplicationCommandType, ApplicationCommandOptionType } from "discord-api-types/v9";
 import { reducePermissions } from "../utils/permissions";
 import snakecaseKeys from "snakecase-keys";
+import { DBI } from "../DBI";
+import { DBIInteractionLocale } from "../types/InteractionLocale";
 
 const PUBLISHABLE_TYPES = ["ChatInput", "UserContextMenu", "MessageContextMenu"];
+const ORIGINAL_LOCALES = ["da", "de", "en-GB", "en-US", "es-ES", "fr", "hr", "it", "lt", "hu", "nl", "no", "pl", "pt-BR", "ro", "fi", "sv-SE", "vi", "tr", "cs", "el", "bg", "ru", "uk", "hi", "th", "zh-CN", "ja", "zh-TW", "ko"];
 
 export async function publishInteractions(
   clientToken: string,
   interactions: Discord.Collection<string, DBIChatInput>,
+  interactionsLocales: Discord.Collection<string, DBIInteractionLocale>,
   publishType: "Guild" | "Global",
   guildId?: string
 ) {
@@ -20,11 +24,12 @@ export async function publishInteractions(
 
   const me: RESTGetAPIUserResult = await rest.get(Routes.user()) as any;
   
-  const body: RESTPutAPIApplicationCommandsJSONBody =
+  let body: RESTPutAPIApplicationCommandsJSONBody =
     interactions.reduce((all, current) => {
       switch (current.type) {
         case "ChatInput": {
           let nameSplitted = current.name.split(" ");
+          let localeData = formatLocale(interactionsLocales.get(current.name) ?? {} as any);
           switch (nameSplitted.length) {
             case 1: {
               all.push({
@@ -33,24 +38,30 @@ export async function publishInteractions(
                 name: nameSplitted[0],
                 default_member_permissions: reducePermissions(current.defaultMemberPermissions).toString(),
                 dm_permission: current.directMessages,
-                options: snakecaseKeys(current.options || [])
+                options: localeifyOptions(current.options || [], localeData.optionsLocales),
+                name_localizations: localeData.nameLocales(0),
+                description_localizations: localeData.descriptionLocales,
               });
               break;
             }
             case 2: {
               let baseItem = all.find(i => i.name == current.name.split(" ")[0] && i.type == "ChatInput");
+              let localeData = formatLocale(interactionsLocales.get(current.name) ?? {} as any);
               let option = {
                 type: ApplicationCommandOptionType.Subcommand,
                 name: nameSplitted[1],
                 description: current.description,
                 default_member_permissions: reducePermissions(current.defaultMemberPermissions).toString(),
                 dm_permission: current.directMessages,
-                options: snakecaseKeys(current.options || [])
+                options: localeifyOptions(current.options || [], localeData.optionsLocales),
+                name_localizations: localeData.nameLocales(1),
+                description_localizations: localeData.descriptionLocales,
               };
               if (!baseItem) {
                 all.push({
                   type: ApplicationCommandType.ChatInput,
                   name: nameSplitted[0],
+                  name_localizations: localeData.nameLocales(0),
                   description: "...",
                   options: [
                     option
@@ -63,15 +74,18 @@ export async function publishInteractions(
             }
             case 3: {
               let level1Item = all.find(i => i.name == current.name.split(" ")[0] && i.type == "ChatInput");
+              let localeData = formatLocale(interactionsLocales.get(current.name) ?? {} as any);
               if (!level1Item) {
                 all.push({
                   type: ApplicationCommandType.ChatInput,
                   name: nameSplitted[0],
+                  name_localizations: localeData.nameLocales(0),
                   description: "...",
                   options: [
                     {
                       type: ApplicationCommandOptionType.SubcommandGroup,
                       name: nameSplitted[1],
+                      name_localizations: localeData.nameLocales(1),
                       description: "...",
                       options: [
                         {
@@ -80,7 +94,9 @@ export async function publishInteractions(
                           description: current.description,
                           default_member_permissions: reducePermissions(current.defaultMemberPermissions).toString(),
                           dm_permission: current.directMessages,
-                          options: snakecaseKeys(current.options || [])
+                          options: localeifyOptions(current.options || [], localeData.optionsLocales),
+                          name_localizations: localeData.nameLocales(2),
+                          description_localizations: localeData.descriptionLocales,
                         }
                       ]
                     }
@@ -92,6 +108,7 @@ export async function publishInteractions(
                   level1Item.options.push({
                     type: ApplicationCommandOptionType.SubcommandGroup,
                     name: nameSplitted[1],
+                    name_localizations: localeData.nameLocales(1),
                     description: "...",
                     options: [
                       {
@@ -100,7 +117,9 @@ export async function publishInteractions(
                         description: current.description,
                         default_member_permissions: reducePermissions(current.defaultMemberPermissions).toString(),
                         dm_permission: current.directMessages,
-                        options: snakecaseKeys(current.options || [])
+                        options: localeifyOptions(current.options || [], localeData.optionsLocales),
+                        name_localizations: localeData.nameLocales(2),
+                        description_localizations: localeData.descriptionLocales
                       }
                     ]
                   })
@@ -111,7 +130,9 @@ export async function publishInteractions(
                     description: current.description,
                     default_member_permissions: reducePermissions(current.defaultMemberPermissions).toString(),
                     dm_permission: current.directMessages,
-                    options: snakecaseKeys(current.options || [])
+                    options: localeifyOptions(current.options || [], localeData.optionsLocales),
+                    name_localizations: localeData.nameLocales(2),
+                    description_localizations: localeData.descriptionLocales,
                   });
                 }
               }
@@ -121,20 +142,26 @@ export async function publishInteractions(
           break;
         }
         case "MessageContextMenu": {
+          let localeData = formatLocale(interactionsLocales.get(current.name) ?? {} as any);
           all.push({
             type: ApplicationCommandType.Message,
             name: current.name,
             default_member_permissions: reducePermissions(current.defaultMemberPermissions).toString(),
-            dm_permission: current.directMessages
+            dm_permission: current.directMessages,
+            name_localizations: localeData.allNameLocales,
+            description_localizations: localeData.descriptionLocales,
           });
           break;
         }
         case "UserContextMenu": {
+          let localeData = formatLocale(interactionsLocales.get(current.name) ?? {} as any);
           all.push({
             type: ApplicationCommandType.User,
             name: current.name,
             default_member_permissions: reducePermissions(current.defaultMemberPermissions).toString(),
-            dm_permission: current.directMessages
+            dm_permission: current.directMessages,
+            name_localizations: localeData.allNameLocales,
+            description_localizations: localeData.descriptionLocales
           });
           break;
         }
@@ -143,6 +170,7 @@ export async function publishInteractions(
       return all;
     }, []);
   
+  body = snakecaseKeys(body);
   
   switch (publishType) {
     case "Global": {
@@ -155,4 +183,53 @@ export async function publishInteractions(
     }
   }
   
+}
+
+export function localeifyOptions(options: any[], localeData: any): any[] {
+  return options.map(i => {
+    return localeData[i.name] ? Object.assign(i, {
+      name_localizations: localeData[i.name].nameLocales,
+      description_localizations: localeData[i.name].descriptionLocales,
+    }) : i;
+  })
+}
+
+export function formatLocale(locale: DBIInteractionLocale): any {
+  let allNameLocales = {};
+  let descriptionLocales = {};
+  let optionsLocales = {};
+
+  function nameLocales(index) {
+    return Object.fromEntries(Object.entries(allNameLocales).map(i => [i[0], (i[1] as string).split(" ").at(index)]));
+  }
+
+  if (!locale?.data) return {
+    nameLocales,
+    allNameLocales,
+    descriptionLocales,
+    optionsLocales
+  };
+
+  Object.entries(locale.data).forEach(([shortLocale, localeData]) => {
+    let longAliases = ORIGINAL_LOCALES.filter(i => i.split("-").at(0) == shortLocale);
+    longAliases.forEach((longLocale) => {
+      allNameLocales[longLocale] = localeData.name;
+      descriptionLocales[longLocale] = localeData.description;
+      Object.entries(localeData.options || []).forEach(([optionName, optionData]) => {
+        if (!optionsLocales[optionName]) optionsLocales[optionName] = {};
+        if (!optionsLocales[optionName].nameLocales) optionsLocales[optionName].nameLocales = {};
+        if (!optionsLocales[optionName].descriptionLocales) optionsLocales[optionName].descriptionLocales = {};
+
+        optionsLocales[optionName].nameLocales[longLocale] = optionData.name;
+        optionsLocales[optionName].descriptionLocales[longLocale] = optionData.description;
+      })
+    });
+  });
+  
+  return {
+    nameLocales,
+    allNameLocales,
+    descriptionLocales,
+    optionsLocales
+  }
 }

package/src/types/Button.ts

@@ -1,11 +1,11 @@
 import Discord from "discord.js";
 import { DBI } from "../DBI";
-import { DBIBaseInteraction, IDBIBaseExecuteCtx } from "./Interaction";
+import { DBIBaseInteraction, IDBIBaseExecuteCtx, TDBIReferencedData } from "./Interaction";
 import { customIdBuilder } from "../utils/customId";
 
 export interface IDBIButtonExecuteCtx extends IDBIBaseExecuteCtx {
   interaction: Discord.ButtonInteraction<Discord.CacheType>;
-  data: ({ [key: string]: any, $ref: string, $unRef(): boolean } | string | number)[];
+  data: TDBIReferencedData[];
 }
 
 export type TDBIButtonOmitted = Omit<DBIButton, "type" | "description" | "dbi" | "toJSON">;

package/src/types/Interaction.ts

@@ -20,6 +20,8 @@ export interface IDBIBaseExecuteCtx {
   other: Record<string, any>;
 }
 
+export type TDBIReferencedData = ({ [key: string]: any, $ref: string, $unRef(): boolean } | string | number);
+
 export type TDBIInteractionTypes =
   | "ChatInput"
   | "UserContextMenu"

package/src/types/InteractionLocale.ts

@@ -0,0 +1,28 @@
+import { DBI } from "../DBI";
+import { TDBILocaleString } from "./Locale";
+
+export type TDBIInteractionLocaleData = {
+  [K in TDBILocaleString]?: {
+    name: string;
+    description: string;
+    options?: {
+      [k: string]: {
+        name: string;
+        description: string;
+      }
+    }
+  };
+};
+
+export type TDBIInteractionLocaleOmitted = Omit<DBIInteractionLocale, "dbi">;
+
+export class DBIInteractionLocale {
+  name: string;
+  data: TDBIInteractionLocaleData;
+  dbi: DBI;
+  constructor(dbi, cfg: TDBIInteractionLocaleOmitted) {
+    this.dbi = dbi;
+    this.name = cfg.name;
+    this.data = cfg.data;
+  }
+}

package/src/types/Locale.ts

@@ -1,3 +1,4 @@
+// @ts-ignore
 import * as stuffs from "stuffs";
 import { DBI } from "../DBI";
 
@@ -11,7 +12,7 @@ export interface LangConstructorObject {
 
 export type TDBILocaleString = "en" | "bg" | "zh" | "hr" | "cs" | "da" | "nl" | "fi" | "fr" | "de" | "el" | "hi" | "hu" | "it" | "ja" | "ko" | "no" | "pl" | "pt" | "ro" | "ru" | "es" | "sv" | "th" | "tr" | "uk" | "vi";
 
-export type TDBILocaleConstructor = Omit<DBILocale & { data: LangConstructorObject }, "dbi">;
+export type TDBILocaleConstructor = Omit<DBILocale, "data" | "dbi"> & { data: LangConstructorObject };
 
 export class DBILocale {
   name: TDBILocaleString;
@@ -22,18 +23,18 @@ export class DBILocale {
     this.dbi = dbi;
     this.name = cfg.name;
     this._data = cfg.data;
-    this.data = convert(cfg.data);
+    this.data = convertLang(cfg.data);
   }
 }
 
-function convert(data) {
+export function convertLang(data: LangConstructorObject): LangObject {
   return Object.fromEntries(Object.entries(data).map(([key, value]) => {
     if (typeof value === "string") {
-      return [key, (...args) => {
+      return [key, (...args: any[]) => {
         return stuffs.mapReplace(value, Object.fromEntries(args.map((t, i) => [`{${i}}`, t])))
       }]
     } else {
-      return [key, convert(value)];
+      return [key, convertLang(value)];
     }
   }))
 }

package/src/types/Modal.ts

@@ -1,12 +1,12 @@
 import { DBI } from "../DBI";
-import { DBIBaseInteraction, IDBIBaseExecuteCtx } from "./Interaction";
+import { DBIBaseInteraction, IDBIBaseExecuteCtx, TDBIReferencedData } from "./Interaction";
 import Discord from "discord.js";
 import { customIdBuilder } from "../utils/customId";
 
 export interface IDBIModalExecuteCtx extends IDBIBaseExecuteCtx {
   interaction: Discord.ModalSubmitInteraction<Discord.CacheType>;
 
-  data: ({ [key: string]: any, $ref: string, $unRef(): boolean } | string | number)[];
+  data: TDBIReferencedData[];
 }
 
 export type TDBIModalOmitted = Omit<DBIModal, "type" | "description" | "dbi" | "toJSON">;