@mostfeatured/dbi 0.0.1

package/src/types/Locale.ts

@@ -0,0 +1,39 @@
+import * as stuffs from "stuffs";
+import { DBI } from "../DBI";
+
+export interface LangObject {
+  [property: string]: LangObject & ((...args: any[]) => string);
+}
+
+export interface LangConstructorObject {
+  [property: string]: LangConstructorObject | string;
+}
+
+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 class DBILocale {
+  name: TDBILocaleString;
+  data: LangObject
+  private _data: LangConstructorObject;
+  dbi: DBI;
+  constructor(dbi: DBI, cfg: TDBILocaleConstructor) {
+    this.dbi = dbi;
+    this.name = cfg.name;
+    this._data = cfg.data;
+    this.data = convert(cfg.data);
+  }
+}
+
+function convert(data) {
+  return Object.fromEntries(Object.entries(data).map(([key, value]) => {
+    if (typeof value === "string") {
+      return [key, (...args) => {
+        return stuffs.mapReplace(value, Object.fromEntries(args.map((t, i) => [`{${i}}`, t])))
+      }]
+    } else {
+      return [key, convert(value)];
+    }
+  }))
+}

package/src/types/MessageContextMenu.ts

@@ -0,0 +1,23 @@
+import { DBI } from "../DBI";
+import { DBIBaseInteraction, IDBIBaseExecuteCtx } from "./Interaction";
+import Discord from "discord.js";
+
+export type TDBIMessageContextMenuOmitted = Omit<DBIMessageContextMenu, "type" | "description" | "dbi" | "options">;
+
+export interface IDBIMessageContextMenuExecuteCtx extends IDBIBaseExecuteCtx {
+  interaction: Discord.MessageContextMenuCommandInteraction<Discord.CacheType>;
+}
+
+
+export class DBIMessageContextMenu extends DBIBaseInteraction {
+  constructor(dbi: DBI, cfg: TDBIMessageContextMenuOmitted) {
+    super(dbi, {
+      ...(cfg as any),
+      type: "MessageContextMenu"
+    });
+  }
+
+  directMessages?: boolean;
+  defaultMemberPermissions?: Discord.PermissionsString[];
+  override onExecute(ctx: IDBIMessageContextMenuExecuteCtx): Promise<any> | any {}
+}

package/src/types/Modal.ts

@@ -0,0 +1,32 @@
+import { DBI } from "../DBI";
+import { DBIBaseInteraction, IDBIBaseExecuteCtx } 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)[];
+}
+
+export type TDBIModalOmitted = Omit<DBIModal, "type" | "description" | "dbi" | "toJSON">;
+
+export class DBIModal extends DBIBaseInteraction {
+  constructor(dbi: DBI, cfg: TDBIModalOmitted) {
+    super(dbi, {
+      ...(cfg as any),
+      type: "Modal"
+    })
+  }
+
+  declare options: Omit<Discord.ModalComponentData, "customId">;
+
+  override onExecute(ctx: IDBIModalExecuteCtx): Promise<any> | any { };
+
+  toJSON(...customData: (string | number | object)[]): Discord.ModalComponentData {
+    return {
+      ...this.options,
+      customId: customIdBuilder(this.dbi, this.name, customData)
+    } as any;
+  };
+}

package/src/types/SelectMenu.ts

@@ -0,0 +1,32 @@
+import Discord from "discord.js";
+import { DBI } from "../DBI";
+import { DBIBaseInteraction, IDBIBaseExecuteCtx } from "./Interaction";
+import { customIdBuilder } from "../utils/customId";
+
+export interface IDBISelectMenuExecuteCtx extends IDBIBaseExecuteCtx {
+  interaction: Discord.ButtonInteraction<Discord.CacheType>;
+  data: (string | number | { [key: string]: any, $ref: string, $unRef(): boolean })[];
+}
+
+export type TDBISelectMenuOmitted = Omit<DBIBaseInteraction, "type" | "description" | "dbi" | "toJSON">;
+
+export class DBISelectMenu extends DBIBaseInteraction {
+  constructor(dbi: DBI, args: TDBISelectMenuOmitted) {
+    super(dbi, {
+      ...(args as any),
+      type: "SelectMenu",
+    });
+  }
+
+  declare options: Omit<Discord.SelectMenuComponentData, "customId" | "type">;
+
+  override onExecute(ctx: IDBISelectMenuExecuteCtx): Promise<any> | any { };
+
+  toJSON(...customData: (string | number | object)[]): Discord.SelectMenuComponentData {
+    return {
+      ...this.options,
+      customId: customIdBuilder(this.dbi, this.name, customData),
+      type: Discord.ComponentType.SelectMenu
+    } as any
+  };
+}

package/src/types/UserContextMenu.ts

@@ -0,0 +1,21 @@
+import { DBI } from "../DBI";
+import { DBIBaseInteraction, IDBIBaseExecuteCtx } from "./Interaction";
+import Discord from "discord.js";
+
+export type TDBIUserContextMenuOmitted = Omit<DBIUserContextMenu, "type" | "description" | "dbi" | "options">;
+
+export interface IDBIUserContextMenuExecuteCtx extends IDBIBaseExecuteCtx {
+  interaction: Discord.UserContextMenuCommandInteraction<Discord.CacheType>;
+}
+
+export class DBIUserContextMenu extends DBIBaseInteraction {
+  constructor(dbi: DBI, cfg: TDBIUserContextMenuOmitted) {
+    super(dbi, {
+      ...(cfg as any),
+      type: "UserContextMenu"
+    });
+  }
+  directMessages?: boolean;
+  defaultMemberPermissions?: Discord.PermissionsString[];
+  override onExecute(ctx: IDBIUserContextMenuExecuteCtx): Promise<any> | any {}
+}

package/src/utils/MemoryStore.ts

@@ -0,0 +1,28 @@
+import _ from "lodash";
+
+export class MemoryStore {
+  store: Record<string, any>;
+  constructor() {
+    this.store = {};
+  }
+  async get(key: string, defaultValue?: any): Promise<any> {
+    let val = _.get(this.store, key);
+    if (!val) {
+      this.set(key, defaultValue);
+      return defaultValue;
+    }
+    return val;
+  }
+
+  async set(key: string, value: any): Promise<any> {
+    return this.store = _.set(this.store, key, value);
+  }
+
+  async del(key: string): Promise<boolean> {
+    return _.unset(this.store, key);
+  }
+
+  async has(key: string): Promise<boolean> {
+    return _.has(this.store, key);
+  }
+}

package/src/utils/customId.ts

@@ -0,0 +1,35 @@
+import { DBI } from "../DBI";
+import * as stuffs from "stuffs";
+
+export function customIdBuilder(dbi: DBI, name: string, customData: any[]): string {
+  let customId = [
+    name,
+    ...customData.map(value => {
+      if (typeof value == "string") return value;
+      if (typeof value == "number") return `π${value}`;
+      let id = stuffs.randomString(8);
+      Object.assign(value, {
+        $ref: id,
+        $unRef() { return dbi.data.refs.delete(id); },
+      })
+      dbi.data.refs.set(id, { at: Date.now(), value });
+      return `¤${id}`;
+    })
+  ].join("—");
+  if (customId.length > 100) throw new Error("Custom id cannot be longer than 100 characters.")
+  return customId;
+}
+
+export function parseCustomId(dbi: DBI, customId: string): {name: string, data: any[]} {
+  let splitted = customId.split("—");
+  let name = splitted.shift();
+  let data = splitted.map(value => {
+    if (value.startsWith("π")) return Number(value.slice(1));
+    if (value.startsWith("¤")) return dbi.data.refs.get(value.slice(1))?.value;
+    return value;
+  });
+  return {
+    name,
+    data
+  }
+}

package/src/utils/permissions.ts

@@ -0,0 +1,5 @@
+import { PermissionFlagsBits, PermissionsString } from "discord.js";
+
+export function reducePermissions(permStrings: PermissionsString[] = []): bigint {
+  return permStrings.reduce((all, curr) => PermissionFlagsBits[curr] | all, 0n);
+}

package/src/utils/recursiveImport.ts

@@ -0,0 +1,15 @@
+import fs from "fs";
+import path from "path";
+
+export async function recursiveImport(folderPath: string): Promise<any> {
+  let files = await fs.promises.readdir(folderPath, { withFileTypes: true });
+
+  for (const file of files) {
+    let filePath = path.resolve(folderPath, file.name);
+    if (file.isDirectory()) {
+      await recursiveImport(filePath)
+    } else if (filePath.endsWith(".js")) {
+      await import(filePath)
+    }
+  }
+}

package/tsconfig.json

@@ -0,0 +1,39 @@
+{
+  // Mapped from https://www.typescriptlang.org/tsconfig
+  "compilerOptions": {
+    // Type Checking
+    "allowUnreachableCode": false,
+    "allowUnusedLabels": false,
+    "noFallthroughCasesInSwitch": true,
+    "noImplicitOverride": true,
+    "noImplicitReturns": true,
+    "strict": false,
+    "useUnknownInCatchVariables": true,
+    "noUncheckedIndexedAccess": true,
+    // Modules
+    "module": "commonjs",
+    "moduleResolution": "Node",
+    "resolveJsonModule": true,
+    // Emit
+    "declaration": true,
+    "declarationMap": true,
+    "importHelpers": true,
+    "inlineSources": true,
+    "newLine": "lf",
+    "noEmitHelpers": true,
+    "outDir": "dist",
+    "preserveConstEnums": true,
+    "removeComments": false,
+    "sourceMap": true,
+    "esModuleInterop": true,
+    "forceConsistentCasingInFileNames": true,
+    // Language and Environment
+    "emitDecoratorMetadata": true,
+    "experimentalDecorators": true,
+    "lib": [
+      "ESNext"
+    ],
+    "target": "ESNext",    
+    "useDefineForClassFields": true
+  }
+}