chore(main): release 2.1.1 (#181)

Co-authored-by: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com>

.eslintrc

@@ -3,9 +3,11 @@
     "extends": ["plugin:@typescript-eslint/recommended"],
     "parserOptions": { "ecmaVersion": "latest", "sourceType": "script" },
     "rules": {
-      "@typescript-eslint/no-non-null-assertion": "off",
-      "quotes": [2, "single", { "avoidEscape": true, "allowTemplateLiterals" : true }],
-      "semi": ["error", "always"],
-      "@typescript-eslint/no-empty-interface": 0
+        "@typescript-eslint/no-non-null-assertion": "off",
+        "quotes": [2, "single", { "avoidEscape": true, "allowTemplateLiterals": true }],
+        "semi": ["error", "always"],
+        "@typescript-eslint/no-empty-interface": 0,
+        "@typescript-eslint/ban-types": 0,
+        "@typescript-eslint/no-explicit-any": "off"
     }
-  }
+}

.github/CODEOWNERS

@@ -1 +1 @@
-src/* @jacoobes
+* @jacoobes

.github/workflows/continuous-integration.yml

@@ -0,0 +1,47 @@
+name: Continuous Integration
+
+on:
+  # Trigger the workflow on push or pull request or custom
+  push:
+    branches:
+      main
+  pull_request_target:
+    branches:
+      main
+  workflow_dispatch:
+
+jobs:
+  Prettier:
+    name: Run Prettier
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Check out Git repository
+        uses: actions/checkout@755da8c3cf115ac066823e79a1e1788f8940201b # v3
+
+      - name: Set up Node.js
+        uses: actions/setup-node@8c91899e586c5b171469028077307d293428b516 # tag=v3
+        with:
+          node-version: 17
+
+      - name: Install pnpm
+        run: npm i -g pnpm
+
+      # Prettier must be in `package.json`
+      - name: Install Node.js dependencies
+        run:  pnpm i
+
+      - name: Run Prettier
+        run: pnpm run pretty
+
+      - name: Create Pull Request
+        id: cpr
+        uses: peter-evans/create-pull-request@v4
+        with:
+          commit-message: "style: pretty please"
+          branch: prettier
+          delete-branch: true
+          branch-suffix: short-commit-hash
+          title: "style: pretty please"
+          body: "pretty pretty prettier"
+          reviewers: EvolutionX-10

.prettierignore

@@ -1,2 +1,3 @@
 .github/
-*.md
+*.md
+dist/

.prettierrc

@@ -1,8 +1,8 @@
 {
-  "semi": true,
-  "trailingComma": "all",
-  "singleQuote": true,
-  "printWidth": 100,
-  "tabWidth": 4,
-  "arrowParens": "avoid"
+    "semi": true,
+    "trailingComma": "all",
+    "singleQuote": true,
+    "printWidth": 100,
+    "tabWidth": 4,
+    "arrowParens": "avoid"
 }

CHANGELOG.md

@@ -1,5 +1,68 @@
 # Changelog
 
+## [2.1.1](https://github.com/sern-handler/handler/compare/v2.1.0...v2.1.1) (2022-12-31)
+
+
+### Bug Fixes
+
+* modals remapping ([a13df6f](https://github.com/sern-handler/handler/commit/a13df6fb424d256476284da49024dbe56e82baab))
+
+## [2.1.0](https://github.com/sern-handler/handler/compare/v2.0.0...v2.1.0) (2022-12-30)
+
+
+### Features
+
+* grammar ([c30aac4](https://github.com/sern-handler/handler/commit/c30aac476cdc2094de34f9f67b5805204cc5e4dd))
+
+
+### Bug Fixes
+
+* multi parameter events ([e986535](https://github.com/sern-handler/handler/commit/e98653593566ef4635493e0c997bd107a7a3a2a2))
+
+## [2.0.0](https://github.com/sern-handler/handler/compare/v1.2.1...v2.0.0) (2022-12-28)
+
+
+### ⚠ BREAKING CHANGES
+
+* (2.0 global services) ([#156](https://github.com/sern-handler/handler/issues/156))
+
+### Features
+
+* (2.0 global services) ([#156](https://github.com/sern-handler/handler/issues/156)) ([1455622](https://github.com/sern-handler/handler/commit/14556223fd6f79b797fb2aee03e795d4f4e94a8b))
+
+## [1.2.1](https://github.com/sern-handler/handler/compare/v1.2.0...v1.2.1) (2022-10-03)
+
+
+### Bug Fixes
+
+* **autocomplete:** now support multiple autocomplete options ([#147](https://github.com/sern-handler/handler/issues/147)) ([cbad738](https://github.com/sern-handler/handler/commit/cbad7380e1993b96c643f365726457f63e4fbd5d))
+
+## [1.2.0](https://github.com/sern-handler/handler/compare/v1.1.0...v1.2.0) (2022-09-28)
+
+
+### Features
+
+* allow constructable modules ([#133](https://github.com/sern-handler/handler/issues/133)) ([03936eb](https://github.com/sern-handler/handler/commit/03936eb2ea1d1af7cada04d77bb8345d63a5e20f))
+* classmodules@arcs ([#143](https://github.com/sern-handler/handler/issues/143)) ([5028886](https://github.com/sern-handler/handler/commit/50288867a5b171511941a1be3877d721694e9f77))
+* update CODEOWNERS ([6b8995d](https://github.com/sern-handler/handler/commit/6b8995d149c857558415a6c151a3f575ec373445))
+
+
+### Reverts
+
+* feat of allow constructable modules ([#138](https://github.com/sern-handler/handler/issues/138)) ([82bbdda](https://github.com/sern-handler/handler/commit/82bbddac8d656b60b3a1fb2471ea03ee5224f5c3))
+
+## [1.1.0](https://github.com/sern-handler/handler/compare/v1.0.0...v1.1.0) (2022-08-29)
+
+
+### Features
+
+* add proper error handling ([#115](https://github.com/sern-handler/handler/issues/115)) ([395549c](https://github.com/sern-handler/handler/commit/395549c173cb62a18205e451bf2cb5579ba9a6e0))
+
+
+### Miscellaneous Chores
+
+* release 1.1.0 ([8a373de](https://github.com/sern-handler/handler/commit/8a373de880ff18df85af812adf9f6f6a4f45028d))
+
 ## 1.0.0 (2022-08-15)
 
 

README.md

@@ -1,17 +1,17 @@
 <div align="center">
-  <img src="https://raw.githubusercontent.com/sern-handler/.github/main/banner.png" width="900px">
+  <img src="https://raw.githubusercontent.com/sern-handler/.github/main/banner.png" width="900px" />
 </div>
 
 <h1 align="center">Handlers. Redefined.</h1>
 <h4 align="center">A customizable, batteries-included, powerful discord.js framework to streamline bot development.</h4>
 
-<div align="center" style="margin-top: 10px">
-  <img src="https://img.shields.io/badge/open-source-brightgreen">
+<div align="center" styles="margin-top: 10px">
+  <img src="https://img.shields.io/badge/open-source-brightgreen" />
   <a href="https://www.npmjs.com/package/@sern/handler"><img src="https://img.shields.io/npm/v/@sern/handler?maxAge=3600" alt="NPM version" /></a>
   <a href="https://www.npmjs.com/package/@sern/handler"><img src="https://img.shields.io/npm/dt/@sern/handler?maxAge=3600" alt="NPM downloads" /></a>
-  <a href="https://opensource.org/licenses/MIT"><img src="https://img.shields.io/badge/license-MIT-brightgreen" alt="License MIT"></a>
-  <a href="https://sern-handler.js.org"><img alt="docs.rs" src="https://img.shields.io/docsrs/docs"></a>
-  <img alt="Lines of code" src="https://img.shields.io/badge/total%20lines-2k-blue">
+  <a href="https://opensource.org/licenses/MIT"><img src="https://img.shields.io/badge/license-MIT-brightgreen" alt="License MIT" /></a>
+  <a href="https://sern.dev"><img alt="docs.rs" src="https://img.shields.io/docsrs/docs" /></a>
+  <img alt="Lines of code" src="https://img.shields.io/badge/total%20lines-2k-blue" />
 </div>
 
 
@@ -33,9 +33,9 @@ pnpm add @sern/handler
 
 * Support for discord.js v14 and all interactions
 * Hybrid commands
-* lightweight and customizable
+* Lightweight and customizable
 * ESM, CommonJS and TypeScript support
-* A powerful cli and awesome community-made plugins
+* A powerful CLI and awesome community-made plugins
 
 ## 👶 Basic Usage
 
@@ -58,11 +58,20 @@ const client = new Client({
     GatewayIntentBits.GuildMessages
   ]
 });
+export const useContainer = Sern.makeDependencies({
+    build: root => root
+        .add({ '@sern/client': single(client)  })
+        .add({ '@sern/logger': single(new DefaultLogging()) })
+});
 
+//View docs for all options
 Sern.init({
-  client,   
-  defaultPrefix,   
-  commands : 'src/commands',
+	defaultPrefix: '!', // removing defaultPrefix will shut down text commands
+	commands: 'src/commands',
+	// events: 'src/events' (optional),
+	containerConfig : {
+		get: useContainer
+	}
 });
 
 client.login(token);
@@ -71,7 +80,7 @@ client.login(token);
 #### ` ping.js (CommonJS)`
 
 ```js
-const { CommandType } = require('@sern/handler');
+const { CommandType, commandModule } = require('@sern/handler');
 
 exports.default = commandModule({
   name: 'ping',
@@ -83,7 +92,7 @@ exports.default = commandModule({
 });
 ```
 
-See our [templates](https://github.com/sern-handler/templates) for TypeScript examples and more
+See our [templates](https://github.com/sern-handler/templates) for TypeScript examples and more.
 
 ## 💻 CLI
 
@@ -91,12 +100,12 @@ It is **highly encouraged** to use the [command line interface](https://github.c
 
 ## 🔗 Links
 
-- [Official Documentation and Guide](https://sern-handler.js.org)
-- [Support Server](https://discord.com/invite/mmyCTnYtbF)
+- [Official Documentation and Guide](https://sern.dev)
+- [Support Server](https://sern.dev/discord)
 
 ## 👋 Contribute
 
-- Read our contribution [guidelines](https://github.com/sern-handler/handler) carefully
+- Read our contribution [guidelines](./.github/CONTRIBUTING.md) carefully
 - Pull up on [issues](https://github.com/sern-handler/handler/issues) and report bugs
 - All kinds of contributions are welcomed.
 

package.json

@@ -1,54 +1,55 @@
 {
-  "name": "@sern/handler",
-  "version": "1.0.0",
-  "description": "A customizable, batteries-included, powerful discord.js framework to automate and streamline bot development.",
-  "main": "dist/cjs/index.cjs",
-  "module": "dist/esm/index.mjs",
-  "types": "dist/index.d.ts",
-  "exports": {
-    ".": {
-      "import": "./dist/esm/index.mjs",
-      "require": "./dist/cjs/index.cjs"
-    }
-  },
-  "scripts": {
-    "watch": "tsup --watch --dts",
-    "clean-modules": "rimraf node_modules/ && npm install",
-    "lint": "eslint src/**/*.ts",
-    "format": "eslint src/**/*.ts --fix",
-    "build": "tsup && node scripts/mkjson.mjs dist/cjs dist/esm && tsup --dts-only --outDir dist",
-    "publish": "npm run build && npm publish"
-  },
-  "keywords": [
-    "sern-handler",
-    "sern",
-    "handler",
-    "sern handler",
-    "wrapper",
-    "discord.js",
-    "framework"
-  ],
-  "author": "SernDevs",
-  "license": "MIT",
-  "dependencies": {
-    "rxjs": "^7.5.6",
-    "ts-pattern": "^4.0.2",
-    "ts-results-es": "^3.5.0"
-  },
-  "devDependencies": {
-    "@typescript-eslint/eslint-plugin": "5.32.0",
-    "@typescript-eslint/parser": "5.32.0",
-    "eslint": "8.21.0",
-    "prettier": "2.7.1",
-    "tsup": "^6.1.3",
-    "typescript": "4.7.4"
-  },
-  "peerDependencies": {
-    "discord.js": "^14.2.x"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/sern-handler/handler.git"
-  },
-  "homepage": "https://sern-handler.js.org"
+    "name": "@sern/handler",
+    "packageManager": "pnpm@7.18.2",
+    "version": "2.1.1",
+    "description": "A customizable, batteries-included, powerful discord.js framework to automate and streamline bot development.",
+    "main": "dist/cjs/index.cjs",
+    "module": "dist/esm/index.mjs",
+    "types": "dist/index.d.ts",
+    "exports": {
+        ".": {
+            "import": "./dist/esm/index.mjs",
+            "require": "./dist/cjs/index.cjs"
+        }
+    },
+    "scripts": {
+        "watch": "tsup --watch --dts",
+        "clean-modules": "rimraf node_modules/ && npm install",
+        "lint": "eslint src/**/*.ts",
+        "format": "eslint src/**/*.ts --fix",
+        "build": "tsup && node scripts/mkjson.mjs dist/cjs dist/esm && tsup --dts-only --outDir dist",
+        "publish": "npm run build && npm publish",
+        "pretty": "prettier --write ."
+    },
+    "keywords": [
+        "sern-handler",
+        "sern",
+        "handler",
+        "sern handler",
+        "wrapper",
+        "discord.js",
+        "framework"
+    ],
+    "author": "SernDevs",
+    "license": "MIT",
+    "dependencies": {
+        "iti": "^0.5.0",
+        "rxjs": "^7.5.6",
+        "ts-pattern": "^4.0.2",
+        "ts-results-es": "^3.5.0"
+    },
+    "devDependencies": {
+        "@typescript-eslint/eslint-plugin": "5.47.1",
+        "@typescript-eslint/parser": "5.47.1",
+        "eslint": "8.30.0",
+        "prettier": "2.8.1",
+        "tsup": "^6.1.3",
+        "typescript": "4.9.4",
+        "discord.js": ">= ^14.7.x"
+    },
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/sern-handler/handler.git"
+    },
+    "homepage": "https://sern.dev"
 }

renovate.json

@@ -1,14 +1,14 @@
 {
-	"major": {
-		"dependencyDashboardApproval": true,
-		"reviewers": ["EvolutionX-10", "jacoobes", "Murtatrxx"]
-	},
-	"minor": {
-		"reviewers": ["jacoobes", "Murtatrxx"]
-	},
-	"schedule": ["every weekend"],
-	"lockFileMaintenance": {
-		"enabled": true,
-		"automerge": false
-	}
+    "major": {
+        "dependencyDashboardApproval": true,
+        "reviewers": ["EvolutionX-10", "jacoobes", "Murtatrxx"]
+    },
+    "minor": {
+        "reviewers": ["jacoobes", "Murtatrxx"]
+    },
+    "schedule": ["every weekend"],
+    "lockFileMaintenance": {
+        "enabled": true,
+        "automerge": false
+    }
 }

scripts/mkjson.mjs

@@ -1,15 +1,13 @@
-import { writeFile } from 'fs/promises'
+import { writeFile } from 'fs/promises';
 import { join } from 'path';
 // A quick script to regenerate package.jsons for each cjs and esm after tsup cleans distributions
 const locations = process.argv;
 locations.shift();
 locations.shift();
-for(const loc of locations) {
-    if(loc.endsWith('cjs')) {
-        await writeFile(join(loc, 'package.json'), JSON.stringify({ type : 'commonjs' }))
+for (const loc of locations) {
+    if (loc.endsWith('cjs')) {
+        await writeFile(join(loc, 'package.json'), JSON.stringify({ type: 'commonjs' }));
     } else {
-        await writeFile(join(loc, 'package.json'), JSON.stringify({ type : 'module' }))
+        await writeFile(join(loc, 'package.json'), JSON.stringify({ type: 'module' }));
     }
 }
-
-

src/handler/contracts/errorHandling.ts

@@ -0,0 +1,51 @@
+import type { Observable } from 'rxjs';
+import type { Logging } from './logging';
+import { useContainerRaw } from '../dependencies/provider';
+import util from 'util';
+export interface ErrorHandling {
+    /**
+     * Number of times the process should throw an error until crashing and exiting
+     */
+    keepAlive: number;
+
+    /**
+     * Utility function to crash
+     * @param error
+     */
+    crash(error: Error): never;
+
+    /**
+     * A function that is called on every crash. Updates keepAlive
+     * @param error
+     */
+    updateAlive(error: Error): void;
+}
+
+export class DefaultErrorHandling implements ErrorHandling {
+    keepAlive = 5;
+    crash(error: Error): never {
+        throw error;
+    }
+    updateAlive(e: Error) {
+        this.keepAlive--;
+    }
+}
+
+export function handleError<C>(crashHandler: ErrorHandling, logging?: Logging) {
+    return (pload: unknown, caught: Observable<C>) => {
+        // This is done to fit the ErrorHandling contract
+        const err = pload instanceof Error ? pload : Error(util.format(pload));
+        if (crashHandler.keepAlive == 0) {
+            useContainerRaw()
+                ?.disposeAll()
+                .then(() => {
+                    logging?.info({ message: 'Cleaning container and crashing' });
+                });
+            crashHandler.crash(err);
+        }
+        //formatted payload
+        logging?.error({ message: util.format(pload) });
+        crashHandler.updateAlive(err);
+        return caught;
+    };
+}

src/handler/contracts/index.ts

@@ -0,0 +1,3 @@
+export { ErrorHandling, DefaultErrorHandling } from './errorHandling';
+export { Logging, DefaultLogging } from './logging';
+export { ModuleManager, DefaultModuleManager } from './moduleManager';

src/handler/contracts/logging.ts

@@ -0,0 +1,27 @@
+import type { LogPayload } from '../../types/handler';
+
+export interface Logging<T = unknown> {
+    error(payload: LogPayload<T>): void;
+    warning(payload: LogPayload<T>): void;
+    info(payload: LogPayload<T>): void;
+    debug(payload: LogPayload<T>): void;
+}
+
+export class DefaultLogging implements Logging {
+    private date = () => new Date();
+    debug(payload: LogPayload): void {
+        console.debug(`DEBUG: ${this.date().toISOString()} -> ${payload.message}`);
+    }
+
+    error(payload: LogPayload): void {
+        console.error(`ERROR: ${this.date().toISOString()} -> ${payload.message}`);
+    }
+
+    info(payload: LogPayload): void {
+        console.info(`INFO: ${this.date().toISOString()} -> ${payload.message}`);
+    }
+
+    warning(payload: LogPayload): void {
+        console.warn(`WARN: ${this.date().toISOString()} -> ${payload.message}`);
+    }
+}

src/handler/contracts/moduleManager.ts

@@ -0,0 +1,21 @@
+import type { CommandModuleDefs } from '../../types/module';
+import type { CommandType } from '../structures/enums';
+import type { ModuleStore } from '../structures/moduleStore';
+
+export interface ModuleManager {
+    get<T extends CommandType>(
+        strat: (ms: ModuleStore) => CommandModuleDefs[T] | undefined,
+    ): CommandModuleDefs[T] | undefined;
+    set(strat: (ms: ModuleStore) => void): void;
+}
+
+export class DefaultModuleManager implements ModuleManager {
+    constructor(private moduleStore: ModuleStore) {}
+    get<T extends CommandType>(strat: (ms: ModuleStore) => CommandModuleDefs[T] | undefined) {
+        return strat(this.moduleStore);
+    }
+
+    set(strat: (ms: ModuleStore) => void): void {
+        strat(this.moduleStore);
+    }
+}

src/handler/dependencies/index.ts

@@ -0,0 +1 @@
+export { useContainer } from './provider';

src/handler/dependencies/provider.ts

@@ -0,0 +1,90 @@
+import type { Container } from 'iti';
+import { SernError } from '../structures/errors';
+import { BehaviorSubject } from 'rxjs';
+import * as assert from 'assert';
+import type { Dependencies, MapDeps } from '../../types/handler';
+import SernEmitter from '../sernEmitter';
+import { _const, ok } from '../utilities/functions';
+import { DefaultErrorHandling, DefaultModuleManager, Logging } from '../contracts';
+import { ModuleStore } from '../structures/moduleStore';
+import { Ok, Result } from 'ts-results-es';
+import { DefaultLogging } from '../contracts';
+
+export const containerSubject = new BehaviorSubject<Container<
+    Dependencies,
+    Partial<Dependencies>
+> | null>(null);
+export function composeRoot<T extends Dependencies>(
+    root: Container<Partial<T>, Partial<Dependencies>>,
+    exclusion: Set<keyof Dependencies>,
+) {
+    const client = root.get('@sern/client');
+    assert.ok(client !== undefined, SernError.MissingRequired);
+    //A utility function checking if a dependency has been declared excluded
+    const excluded = (key: keyof Dependencies) => exclusion.has(key);
+    //Wraps a fetch to the container in a Result, deferring the action
+    const get = <T>(key: keyof Dependencies) => Result.wrap(() => root.get(key) as T);
+    const getOr = (key: keyof Dependencies, elseAction: () => unknown) => {
+        //Gets dependency but if an Err, map to a function that upserts.
+        const dep = get(key).mapErr(() => elseAction);
+        if (dep.err) {
+            //Defers upsert until final check here
+            return dep.val();
+        }
+    };
+    const xGetOr = (key: keyof Dependencies, action: () => unknown) => {
+        if (excluded(key)) {
+            get(key) //if dev created a dependency but excluded, deletes on root composition
+                .andThen(() => Ok(root.delete(key)))
+                .unwrapOr(ok());
+        } else {
+            getOr(key, action);
+        }
+    };
+    xGetOr('@sern/emitter', () =>
+        root.upsert({
+            '@sern/emitter': _const(new SernEmitter()),
+        }),
+    );
+    //An "optional" dependency
+    xGetOr('@sern/logger', () => {
+        root.upsert({
+            '@sern/logger': _const(new DefaultLogging()),
+        });
+    });
+    xGetOr('@sern/store', () =>
+        root.upsert({
+            '@sern/store': _const(new ModuleStore()),
+        }),
+    );
+    xGetOr('@sern/modules', () =>
+        root.upsert(ctx => ({
+            '@sern/modules': _const(new DefaultModuleManager(ctx['@sern/store'] as ModuleStore)),
+        })),
+    );
+    xGetOr('@sern/errors', () =>
+        root.upsert({
+            '@sern/errors': _const(new DefaultErrorHandling()),
+        }),
+    );
+    //If logger exists, log info, else do nothing.
+    get<Logging>('@sern/logger')
+        .map(logger => logger.info({ message: 'All dependencies loaded successfully' }))
+        .unwrapOr(ok());
+}
+
+export function useContainer<T extends Dependencies>() {
+    const container = containerSubject.getValue()! as unknown as Container<T, {}>;
+    assert.ok(container !== null, 'useContainer was called before Sern#init');
+    //weird edge case, why can i not use _const here?
+    return <V extends (keyof T)[]>(...keys: [...V]) =>
+        keys.map(key => Result.wrap(() => container.get(key)).unwrapOr(undefined)) as MapDeps<T, V>;
+}
+
+/**
+ * Returns the underlying data structure holding all dependencies.
+ * Exposes some methods from iti
+ */
+export function useContainerRaw() {
+    return containerSubject.getValue();
+}

src/handler/events/dispatchers.ts

@@ -1,32 +1,45 @@
-import type {
-    BothCommand,
-    ButtonCommand,
-    ContextMenuMsg,
-    ContextMenuUser,
-    ModalSubmitCommand,
-    SelectMenuCommand,
-    SlashCommand,
-} from '../structures/module';
 import Context from '../structures/context';
-import type { SlashOptions } from '../../types/handler';
-import { asyncResolveArray } from '../utilities/asyncResolveArray';
+import type { Payload, SlashOptions } from '../../types/handler';
+import { arrAsync } from '../utilities/arrAsync';
 import { controller } from '../sern';
 import type {
     ButtonInteraction,
     ModalSubmitInteraction,
-    SelectMenuInteraction,
     AutocompleteInteraction,
     ChatInputCommandInteraction,
     Interaction,
     UserContextMenuCommandInteraction,
     MessageContextMenuCommandInteraction,
 } from 'discord.js';
-import { isAutocomplete } from '../utilities/predicates';
 import { SernError } from '../structures/errors';
 import treeSearch from '../utilities/treeSearch';
+import type {
+    BothCommand,
+    ButtonCommand,
+    ContextMenuMsg,
+    ContextMenuUser,
+    ModalSubmitCommand,
+    StringSelectCommand,
+    SlashCommand,
+    UserSelectCommand,
+    ChannelSelectCommand,
+    MentionableSelectCommand,
+    RoleSelectCommand,
+} from '../../types/module';
+import type SernEmitter from '../sernEmitter';
+import { EventEmitter } from 'events';
+import type {
+    DiscordEventCommand,
+    ExternalEventCommand,
+    SernEventCommand,
+} from '../structures/events';
+import * as assert from 'assert';
+import { reducePlugins } from '../utilities/functions';
+import { concatMap, from, fromEvent, map, of } from 'rxjs';
+import type { MessageComponentInteraction } from 'discord.js';
 
 export function applicationCommandDispatcher(interaction: Interaction) {
-    if (isAutocomplete(interaction)) {
+    if (interaction.isAutocomplete()) {
         return dispatchAutocomplete(interaction);
     } else {
         const ctx = Context.wrap(interaction as ChatInputCommandInteraction);
@@ -34,7 +47,7 @@ export function applicationCommandDispatcher(interaction: Interaction) {
         return (mod: BothCommand | SlashCommand) => ({
             mod,
             execute: () => mod.execute(ctx, args),
-            eventPluginRes: asyncResolveArray(
+            eventPluginRes: arrAsync(
                 mod.onEvent.map(plugs => plugs.execute([ctx, args], controller)),
             ),
         });
@@ -48,7 +61,7 @@ export function dispatchAutocomplete(interaction: AutocompleteInteraction) {
             return {
                 mod,
                 execute: () => selectedOption.command.execute(interaction),
-                eventPluginRes: asyncResolveArray(
+                eventPluginRes: arrAsync(
                     selectedOption.command.onEvent.map(e => e.execute(interaction, controller)),
                 ),
             };
@@ -63,7 +76,7 @@ export function modalCommandDispatcher(interaction: ModalSubmitInteraction) {
     return (mod: ModalSubmitCommand) => ({
         mod,
         execute: () => mod.execute(interaction),
-        eventPluginRes: asyncResolveArray(
+        eventPluginRes: arrAsync(
             mod.onEvent.map(plugs => plugs.execute([interaction], controller)),
         ),
     });
@@ -73,18 +86,26 @@ export function buttonCommandDispatcher(interaction: ButtonInteraction) {
     return (mod: ButtonCommand) => ({
         mod,
         execute: () => mod.execute(interaction),
-        eventPluginRes: asyncResolveArray(
+        eventPluginRes: arrAsync(
             mod.onEvent.map(plugs => plugs.execute([interaction], controller)),
         ),
     });
 }
 
-export function selectMenuCommandDispatcher(interaction: SelectMenuInteraction) {
-    return (mod: SelectMenuCommand) => ({
+export function selectMenuCommandDispatcher(interaction: MessageComponentInteraction) {
+    //safe casts because command type runtime check
+    return (
+        mod:
+            | StringSelectCommand
+            | UserSelectCommand
+            | ChannelSelectCommand
+            | MentionableSelectCommand
+            | RoleSelectCommand,
+    ) => ({
         mod,
-        execute: () => mod.execute(interaction),
-        eventPluginRes: asyncResolveArray(
-            mod.onEvent.map(plugs => plugs.execute([interaction], controller)),
+        execute: () => mod.execute(interaction as never),
+        eventPluginRes: arrAsync(
+            mod.onEvent.map(plugs => plugs.execute([interaction as never], controller)),
         ),
     });
 }
@@ -93,7 +114,7 @@ export function ctxMenuUserDispatcher(interaction: UserContextMenuCommandInterac
     return (mod: ContextMenuUser) => ({
         mod,
         execute: () => mod.execute(interaction),
-        eventPluginRes: asyncResolveArray(
+        eventPluginRes: arrAsync(
             mod.onEvent.map(plugs => plugs.execute([interaction], controller)),
         ),
     });
@@ -103,8 +124,86 @@ export function ctxMenuMsgDispatcher(interaction: MessageContextMenuCommandInter
     return (mod: ContextMenuMsg) => ({
         mod,
         execute: () => mod.execute(interaction),
-        eventPluginRes: asyncResolveArray(
+        eventPluginRes: arrAsync(
             mod.onEvent.map(plugs => plugs.execute([interaction], controller)),
         ),
     });
 }
+
+export function sernEmitterDispatcher(e: SernEmitter) {
+    return (cmd: SernEventCommand & { name: string }) => ({
+        source: e,
+        cmd,
+        execute: fromEvent(e, cmd.name).pipe(
+            map(event => ({
+                event,
+                executeEvent: of(event).pipe(
+                    concatMap(event =>
+                        reducePlugins(
+                            from(
+                                arrAsync(
+                                    cmd.onEvent.map(plug =>
+                                        plug.execute([event as Payload], controller),
+                                    ),
+                                ),
+                            ),
+                        ),
+                    ),
+                ),
+            })),
+        ),
+    });
+}
+
+export function discordEventDispatcher(e: EventEmitter) {
+    return (cmd: DiscordEventCommand & { name: string }) => ({
+        source: e,
+        cmd,
+        execute: fromEvent(e, cmd.name).pipe(
+            map(event => ({
+                event,
+                executeEvent: of(event).pipe(
+                    concatMap(event =>
+                        reducePlugins(
+                            from(
+                                arrAsync(
+                                    // god forbid I use any!!!
+                                    cmd.onEvent.map(plug =>
+                                        plug.execute([event as any], controller),
+                                    ),
+                                ),
+                            ),
+                        ),
+                    ),
+                ),
+            })),
+        ),
+    });
+}
+
+export function externalEventDispatcher(e: (e: ExternalEventCommand) => unknown) {
+    return (cmd: ExternalEventCommand & { name: string }) => {
+        const external = e(cmd);
+        assert.ok(external instanceof EventEmitter, `${e} is not an EventEmitter`);
+        return {
+            source: external,
+            cmd,
+            execute: fromEvent(external, cmd.name).pipe(
+                map(event => ({
+                    event,
+                    executeEvent: of(event).pipe(
+                        concatMap(event =>
+                            reducePlugins(
+                                from(
+                                    arrAsync(
+                                        cmd.onEvent.map(plug => plug.execute([event], controller)),
+                                    ),
+                                ),
+                            ),
+                        ),
+                    ),
+                })),
+            ),
+        };
+    };
+}

src/handler/events/eventsHandler.ts

@@ -1,10 +1,31 @@
 import type Wrapper from '../structures/wrapper';
 import { Subject, type Observable } from 'rxjs';
+import type { EventEmitter } from 'events';
+import type SernEmitter from '../sernEmitter';
+import type { ErrorHandling, Logging, ModuleManager } from '../contracts';
 
 export abstract class EventsHandler<T> {
     protected payloadSubject = new Subject<T>();
     protected abstract discordEvent: Observable<unknown>;
-    protected constructor(protected wrapper: Wrapper) {}
+    protected client: EventEmitter;
+    protected emitter: SernEmitter;
+    protected crashHandler: ErrorHandling;
+    protected logger?: Logging;
+    protected modules: ModuleManager;
+    protected constructor({ containerConfig }: Wrapper) {
+        const [client, emitter, crash, modules, logger] = containerConfig.get(
+            '@sern/client',
+            '@sern/emitter',
+            '@sern/errors',
+            '@sern/modules',
+            '@sern/logger',
+        );
+        this.logger = logger as Logging | undefined;
+        this.modules = modules as ModuleManager;
+        this.client = client as EventEmitter;
+        this.emitter = emitter as SernEmitter;
+        this.crashHandler = crash as ErrorHandling;
+    }
     protected abstract init(): void;
     protected abstract setState(state: T): void;
 }

src/handler/events/interactionHandler.ts

@@ -1,17 +1,9 @@
 import type { Interaction } from 'discord.js';
-import { concatMap, from, fromEvent, map, Observable } from 'rxjs';
+import { catchError, concatMap, from, fromEvent, map, Observable } from 'rxjs';
 import type Wrapper from '../structures/wrapper';
 import { EventsHandler } from './eventsHandler';
-import {
-    isApplicationCommand,
-    isAutocomplete,
-    isMessageComponent,
-    isModalSubmit,
-} from '../utilities/predicates';
-import * as Files from '../utilities/readFile';
-import type { CommandModule } from '../structures/module';
 import { SernError } from '../structures/errors';
-import { CommandType } from '../structures/enums';
+import { CommandType, PayloadType } from '../structures/enums';
 import { match, P } from 'ts-pattern';
 import {
     applicationCommandDispatcher,
@@ -24,72 +16,75 @@ import {
 import type {
     ButtonInteraction,
     ModalSubmitInteraction,
-    SelectMenuInteraction,
     UserContextMenuCommandInteraction,
     MessageContextMenuCommandInteraction,
 } from 'discord.js';
 import { executeModule } from './observableHandling';
+import type { CommandModule } from '../../types/module';
+import { handleError } from '../contracts/errorHandling';
+import type { ModuleStore } from '../structures/moduleStore';
+import type { MessageComponentInteraction } from 'discord.js';
 
 export default class InteractionHandler extends EventsHandler<{
     event: Interaction;
     mod: CommandModule;
 }> {
     protected override discordEvent: Observable<Interaction>;
-
-    constructor(protected wrapper: Wrapper) {
+    constructor(wrapper: Wrapper) {
         super(wrapper);
-        this.discordEvent = <Observable<Interaction>>fromEvent(wrapper.client, 'interactionCreate');
+        this.discordEvent = <Observable<Interaction>>fromEvent(this.client, 'interactionCreate');
         this.init();
 
         this.payloadSubject
             .pipe(
                 map(this.processModules),
-                concatMap(({ mod, execute, eventPluginRes }) => {
-                    //resolve all the Results from event plugins
-                    return from(eventPluginRes).pipe(map(res => ({ mod, res, execute })));
-                }),
+                concatMap(
+                    ({ mod, execute, eventPluginRes }) =>
+                        from(eventPluginRes).pipe(map(res => ({ mod, res, execute }))), //resolve all the Results from event plugins
+                ),
                 concatMap(payload => executeModule(wrapper, payload)),
+                catchError(handleError(this.crashHandler, this.logger)),
             )
-            .subscribe({
-                error: err => {
-                    wrapper.sernEmitter?.emit('error', err);
-                },
-            });
+            .subscribe();
     }
 
     override init() {
+        const get = (cb: (ms: ModuleStore) => CommandModule | undefined) => {
+            return this.modules.get(cb);
+        };
         this.discordEvent.subscribe({
             next: event => {
-                if (isMessageComponent(event)) {
-                    const mod = Files.MessageCompCommands[event.componentType].get(
-                        event.customId,
+                if (event.isMessageComponent()) {
+                    const mod = get(ms =>
+                        ms.InteractionHandlers[event.componentType].get(event.customId),
                     );
                     this.setState({ event, mod });
-                } else if (isApplicationCommand(event) || isAutocomplete(event)) {
-                    const mod =
-                        Files.ApplicationCommands[event.commandType].get(
-                            event.commandName,
-                        ) ?? Files.BothCommands.get(event.commandName);
+                } else if (event.isCommand() || event.isAutocomplete()) {
+                    const mod = get(
+                        ms =>
+                            ms.ApplicationCommands[event.commandType].get(event.commandName) ??
+                            ms.BothCommands.get(event.commandName),
+                    );
                     this.setState({ event, mod });
-                } else if (isModalSubmit(event)) {
-                    /**
-                     * maybe move modal submits into message component object maps?
-                     */
-                    const mod = Files.ModalSubmitCommands.get(event.customId);
+                } else if (event.isModalSubmit()) {
+                    const mod = get(ms => ms.ModalSubmit.get(event.customId));
                     this.setState({ event, mod });
                 } else {
                     throw Error('This interaction is not supported yet');
                 }
             },
-            error: e => {
-                this.wrapper.sernEmitter?.emit('error', e);
+            error: reason => {
+                this.emitter.emit('error', { type: PayloadType.Failure, reason });
             },
         });
     }
 
     protected setState(state: { event: Interaction; mod: CommandModule | undefined }): void {
         if (state.mod === undefined) {
-            this.wrapper?.sernEmitter?.emit('warning', 'Found no module for this interaction');
+            this.emitter.emit('warning', {
+                type: PayloadType.Warning,
+                reason: 'Found no module for this interaction',
+            });
         } else {
             //if statement above checks already, safe cast
             this.payloadSubject.next(state as { event: Interaction; mod: CommandModule });
@@ -106,24 +101,27 @@ export default class InteractionHandler extends EventsHandler<{
                 { type: CommandType.Modal },
                 modalCommandDispatcher(event as ModalSubmitInteraction),
             )
+            .with({ type: CommandType.Button }, buttonCommandDispatcher(event as ButtonInteraction))
             .with(
-                { type: CommandType.Button },
-                buttonCommandDispatcher(event as ButtonInteraction),
+                {
+                    type: P.union(
+                        CommandType.RoleSelect,
+                        CommandType.StringSelect,
+                        CommandType.UserSelect,
+                        CommandType.MentionableSelect,
+                        CommandType.ChannelSelect,
+                    ),
+                },
+                selectMenuCommandDispatcher(event as MessageComponentInteraction),
             )
             .with(
-                { type: CommandType.MenuSelect },
-                selectMenuCommandDispatcher(event as SelectMenuInteraction),
-            )
-            .with(
-                { type: CommandType.MenuUser },
+                { type: CommandType.CtxUser },
                 ctxMenuUserDispatcher(event as UserContextMenuCommandInteraction),
             )
             .with(
-                { type: CommandType.MenuMsg },
+                { type: CommandType.CtxMsg },
                 ctxMenuMsgDispatcher(event as MessageContextMenuCommandInteraction),
             )
-            .otherwise(() => {
-                throw Error(SernError.MismatchModule);
-            });
+            .otherwise(() => this.crashHandler.crash(Error(SernError.MismatchModule)));
     }
 }

src/handler/events/messageHandler.ts

@@ -1,15 +1,16 @@
 import { EventsHandler } from './eventsHandler';
-import { concatMap, from, fromEvent, map, Observable, of, switchMap } from 'rxjs';
+import { catchError, concatMap, from, fromEvent, map, Observable, of, switchMap } from 'rxjs';
 import type Wrapper from '../structures/wrapper';
 import type { Message } from 'discord.js';
 import { executeModule, ignoreNonBot, isOneOfCorrectModules } from './observableHandling';
 import { fmt } from '../utilities/messageHelpers';
 import Context from '../structures/context';
-import * as Files from '../utilities/readFile';
-import type { TextCommand } from '../structures/module';
-import { CommandType } from '../structures/enums';
-import { asyncResolveArray } from '../utilities/asyncResolveArray';
+import { CommandType, PayloadType } from '../structures/enums';
+import { arrAsync } from '../utilities/arrAsync';
 import { controller } from '../sern';
+import type { CommandModule, TextCommand } from '../../types/module';
+import { handleError } from '../contracts/errorHandling';
+import type { ModuleStore } from '../structures/moduleStore';
 
 export default class MessageHandler extends EventsHandler<{
     ctx: Context;
@@ -17,36 +18,32 @@ export default class MessageHandler extends EventsHandler<{
     mod: TextCommand;
 }> {
     protected discordEvent: Observable<Message>;
-    public constructor(wrapper: Wrapper) {
+    public constructor(protected wrapper: Wrapper) {
         super(wrapper);
-        this.discordEvent = <Observable<Message>>fromEvent(wrapper.client, 'messageCreate');
+        this.discordEvent = <Observable<Message>>fromEvent(this.client, 'messageCreate');
         this.init();
         this.payloadSubject
             .pipe(
                 switchMap(({ mod, ctx, args }) => {
-                    const res = asyncResolveArray(
-                        mod.onEvent.map(ePlug => {
-                            return ePlug.execute([ctx, args], controller);
-                        }),
+                    const res = arrAsync(
+                        mod.onEvent.map(ep => ep.execute([ctx, args], controller)),
                     );
-                    const execute = () => {
-                        return mod.execute(ctx, args);
-                    };
+                    const execute = () => mod.execute(ctx, args);
                     //resolves the promise and re-emits it back into source
                     return from(res).pipe(map(res => ({ mod, execute, res })));
                 }),
                 concatMap(payload => executeModule(wrapper, payload)),
+                catchError(handleError(this.crashHandler, this.logger)),
             )
-            .subscribe({
-                error: err => {
-                    wrapper.sernEmitter?.emit('error', err);
-                },
-            });
+            .subscribe();
     }
 
     protected init(): void {
         if (this.wrapper.defaultPrefix === undefined) return; //for now, just ignore if prefix doesn't exist
         const { defaultPrefix } = this.wrapper;
+        const get = (cb: (ms: ModuleStore) => CommandModule | undefined) => {
+            return this.modules.get(cb);
+        };
         this.discordEvent
             .pipe(
                 ignoreNonBot(this.wrapper.defaultPrefix),
@@ -55,22 +52,19 @@ export default class MessageHandler extends EventsHandler<{
                     return {
                         ctx: Context.wrap(message),
                         args: <['text', string[]]>['text', rest],
-                        mod:
-                            Files.TextCommands.text.get(prefix) ??
-                            Files.BothCommands.get(prefix) ??
-                            Files.TextCommands.aliases.get(prefix),
+                        mod: get(ms => ms.TextCommands.get(prefix) ?? ms.BothCommands.get(prefix)),
                     };
                 }),
-                concatMap(element => {
-                    return of(element.mod).pipe(
+                concatMap(element =>
+                    of(element.mod).pipe(
                         isOneOfCorrectModules(CommandType.Text),
                         map(mod => ({ ...element, mod })),
-                    );
-                }),
+                    ),
+                ),
             )
             .subscribe({
                 next: value => this.setState(value),
-                error: err => this.wrapper.sernEmitter?.emit('error', err),
+                error: reason => this.emitter.emit('error', { type: PayloadType.Failure, reason }),
             });
     }
 

src/handler/events/observableHandling.ts

@@ -1,12 +1,16 @@
 import type { Message } from 'discord.js';
-import { from, Observable, of, tap, throwError } from 'rxjs';
+import { concatMap, from, map, Observable, of, switchMap, tap, throwError, toArray } from 'rxjs';
 import { SernError } from '../structures/errors';
-import type { Module, CommandModuleDefs, CommandModule } from '../structures/module';
-import type { Result } from 'ts-results-es';
+import { Result } from 'ts-results-es';
 import type { CommandType } from '../structures/enums';
 import type Wrapper from '../structures/wrapper';
-import { PayloadType } from '../structures/enums';
-
+import { PayloadType, PluginType } from '../structures/enums';
+import type { CommandModule, CommandModuleDefs, AnyModule } from '../../types/module';
+import { _const } from '../utilities/functions';
+import type SernEmitter from '../sernEmitter';
+import type { DefinedCommandModule, DefinedEventModule } from '../../types/handler';
+import type { Awaitable } from 'discord.js';
+import { processCommandPlugins } from './userDefinedEventsHandling';
 
 export function ignoreNonBot(prefix: string) {
     return (src: Observable<Message>) =>
@@ -32,7 +36,7 @@ export function ignoreNonBot(prefix: string) {
  * If the current value in Result stream is an error, calls callback.
  * @param cb
  */
-export function errTap<T extends Module>(cb: (err: SernError) => void) {
+export function errTap<T extends AnyModule>(cb: (err: SernError) => void) {
     return (src: Observable<Result<{ mod: T; absPath: string }, SernError>>) =>
         new Observable<{ mod: T; absPath: string }>(subscriber => {
             return src.subscribe({
@@ -56,12 +60,12 @@ export function isOneOfCorrectModules<T extends readonly CommandType[]>(...input
             return src.subscribe({
                 next(mod) {
                     if (mod === undefined) {
-                        return throwError(() => SernError.UndefinedModule);
+                        return throwError(_const(SernError.UndefinedModule));
                     }
                     if (inputs.some(type => (mod.type & type) !== 0)) {
                         subscriber.next(mod as CommandModuleDefs[T[number]]);
                     } else {
-                        return throwError(() => SernError.MismatchModule);
+                        return throwError(_const(SernError.MismatchModule));
                     }
                 },
                 error: e => subscriber.error(e),
@@ -79,21 +83,69 @@ export function executeModule(
         res: Result<void, void>[];
     },
 ) {
+    const emitter = wrapper.containerConfig.get('@sern/emitter')[0] as SernEmitter;
     if (payload.res.every(el => el.ok)) {
-        return from(Promise.resolve(payload.execute())).pipe(
-            tap(() => {
-                wrapper.sernEmitter?.emit('module.activate', {
-                    type: PayloadType.Success,
-                    module: payload.mod,
-                });
+        const executeFn = Result.wrapAsync<unknown, Error | string>(() =>
+            Promise.resolve(payload.execute()),
+        );
+        return from(executeFn).pipe(
+            concatMap(res => {
+                if (res.err) {
+                    return throwError(() => ({
+                        type: PayloadType.Failure,
+                        reason: res.val,
+                        module: payload.mod,
+                    }));
+                }
+                return of(res.val).pipe(
+                    tap(() =>
+                        emitter.emit('module.activate', {
+                            type: PayloadType.Success,
+                            module: payload.mod,
+                        }),
+                    ),
+                );
             }),
         );
     } else {
-        wrapper.sernEmitter?.emit('module.activate', {
+        emitter.emit('module.activate', {
             type: PayloadType.Failure,
             module: payload.mod,
             reason: SernError.PluginFailure,
         });
-        return of(null);
+        return of(undefined);
     }
 }
+
+export function resolvePlugins({
+    mod,
+    cmdPluginRes,
+}: {
+    mod: DefinedCommandModule | DefinedEventModule;
+    cmdPluginRes: {
+        execute: Awaitable<Result<void, void>>;
+        type: PluginType.Command;
+    }[];
+}) {
+    if (mod.plugins.length === 0) {
+        return of({ mod, pluginRes: [] });
+    }
+    // modules with no event plugins are ignored in the previous
+    return from(cmdPluginRes).pipe(
+        switchMap(pl =>
+            from(pl.execute).pipe(
+                map(execute => ({ ...pl, execute })),
+                toArray(),
+            ),
+        ),
+        map(pluginRes => ({ mod, pluginRes })),
+    );
+}
+
+export function processPlugins(payload: {
+    mod: DefinedCommandModule | DefinedEventModule;
+    absPath: string;
+}) {
+    const cmdPluginRes = processCommandPlugins(payload);
+    return of({ mod: payload.mod, cmdPluginRes });
+}

src/handler/events/readyHandler.ts

@@ -1,18 +1,18 @@
 import { EventsHandler } from './eventsHandler';
 import type Wrapper from '../structures/wrapper';
-import { concatMap, fromEvent, Observable, map, take, of, from, toArray, switchMap } from 'rxjs';
-import type { CommandModule } from '../structures/module';
+import { concatMap, fromEvent, Observable, map, take } from 'rxjs';
 import * as Files from '../utilities/readFile';
-import { errTap } from './observableHandling';
-import type { DefinedCommandModule } from '../../types/handler';
-import { basename } from 'path';
-import { CommandType, PayloadType, PluginType } from '../structures/enums';
-import { processCommandPlugins } from './userDefinedEventsHandling';
-import type { Awaitable } from 'discord.js';
+import { errTap, processPlugins, resolvePlugins } from './observableHandling';
+import { CommandType, PayloadType } from '../structures/enums';
 import { SernError } from '../structures/errors';
 import { match } from 'ts-pattern';
-import { type Result, Err, Ok } from 'ts-results-es';
+import { Result } from 'ts-results-es';
 import { ApplicationCommandType, ComponentType } from 'discord.js';
+import type { CommandModule } from '../../types/module';
+import type { DefinedCommandModule, DefinedEventModule } from '../../types/handler';
+import type { ModuleManager } from '../contracts';
+import type { ModuleStore } from '../structures/moduleStore';
+import { _const, err, nameOrFilename, ok } from '../utilities/functions';
 
 export default class ReadyHandler extends EventsHandler<{
     mod: DefinedCommandModule;
@@ -21,12 +21,12 @@ export default class ReadyHandler extends EventsHandler<{
     protected discordEvent!: Observable<{ mod: CommandModule; absPath: string }>;
     constructor(wrapper: Wrapper) {
         super(wrapper);
-        const ready$ = fromEvent(this.wrapper.client, 'ready').pipe(take(1));
+        const ready$ = fromEvent(this.client, 'ready').pipe(take(1));
         this.discordEvent = ready$.pipe(
             concatMap(() =>
-                Files.buildData<CommandModule>(this.wrapper.commands).pipe(
+                Files.buildData<CommandModule>(wrapper.commands).pipe(
                     errTap(reason =>
-                        wrapper.sernEmitter?.emit('module.register', {
+                        this.emitter.emit('module.register', {
                             type: PayloadType.Failure,
                             module: undefined,
                             reason,
@@ -37,23 +37,20 @@ export default class ReadyHandler extends EventsHandler<{
         );
         this.init();
         this.payloadSubject
-            .pipe(
-                concatMap(payload => this.processPlugins(payload)),
-                concatMap(payload => this.resolvePlugins(payload)),
-            )
+            .pipe(concatMap(processPlugins), concatMap(resolvePlugins))
             .subscribe(payload => {
                 const allPluginsSuccessful = payload.pluginRes.every(({ execute }) => execute.ok);
                 if (allPluginsSuccessful) {
-                    const res = registerModule(payload.mod);
+                    const res = registerModule(this.modules, payload.mod);
                     if (res.err) {
-                        throw Error(SernError.InvalidModuleType);
+                        this.crashHandler.crash(Error(SernError.InvalidModuleType));
                     }
-                    wrapper.sernEmitter?.emit('module.register', {
+                    this.emitter.emit('module.register', {
                         type: PayloadType.Success,
                         module: payload.mod,
                     });
                 } else {
-                    wrapper.sernEmitter?.emit('module.register', {
+                    this.emitter.emit('module.register', {
                         type: PayloadType.Failure,
                         module: payload.mod,
                         reason: SernError.PluginFailure,
@@ -68,45 +65,13 @@ export default class ReadyHandler extends EventsHandler<{
         return {
             absPath,
             mod: {
-                name: mod?.name ?? Files.fmtFileName(basename(absPath)),
+                name: nameOrFilename(mod.name, absPath),
                 description: mod?.description ?? '...',
                 ...mod,
             },
         };
     }
 
-    private resolvePlugins({
-        mod,
-        cmdPluginRes,
-    }: {
-        mod: DefinedCommandModule;
-        cmdPluginRes: {
-            name: string;
-            description: string;
-            execute: Awaitable<Result<void, void>>;
-            type: PluginType.Command;
-        }[];
-    }) {
-        if (mod.plugins.length === 0) {
-            return of({ mod, pluginRes: [] });
-        }
-        // modules with no event plugins are ignored in the previous
-        return from(cmdPluginRes).pipe(
-            switchMap(pl =>
-                from(pl.execute).pipe(
-                    map(execute => ({ ...pl, execute })),
-                    toArray(),
-                ),
-            ),
-            map(pluginRes => ({ mod, pluginRes })),
-        );
-    }
-
-    private processPlugins(payload: { mod: DefinedCommandModule; absPath: string }) {
-        const cmdPluginRes = processCommandPlugins(this.wrapper, payload);
-        return of({ mod: payload.mod, cmdPluginRes });
-    }
-
     protected init() {
         this.discordEvent.pipe(map(ReadyHandler.intoDefinedModule)).subscribe({
             next: value => this.setState(value),
@@ -118,42 +83,51 @@ export default class ReadyHandler extends EventsHandler<{
     }
 }
 
-function registerModule(mod: DefinedCommandModule): Result<void, void> {
+function registerModule(
+    manager: ModuleManager,
+    mod: DefinedCommandModule | DefinedEventModule,
+): Result<void, void> {
     const name = mod.name;
-    return match<DefinedCommandModule>(mod)
+    const insert = (cb: (ms: ModuleStore) => void) => {
+        const set = Result.wrap(_const(manager.set(cb)));
+        return set.ok ? ok() : err();
+    };
+    return match<DefinedCommandModule | DefinedEventModule>(mod)
         .with({ type: CommandType.Text }, mod => {
-            mod.alias?.forEach(a => Files.TextCommands.aliases.set(a, mod));
-            Files.TextCommands.text.set(name, mod);
-            return Ok.EMPTY;
-        })
-        .with({ type: CommandType.Slash }, mod => {
-            Files.ApplicationCommands[ApplicationCommandType.ChatInput].set(name, mod);
-            return Ok.EMPTY;
+            mod.alias?.forEach(a => insert(ms => ms.TextCommands.set(a, mod)));
+            return insert(ms => ms.TextCommands.set(name, mod));
         })
+        .with({ type: CommandType.Slash }, mod =>
+            insert(ms => ms.ApplicationCommands[ApplicationCommandType.ChatInput].set(name, mod)),
+        )
         .with({ type: CommandType.Both }, mod => {
-            Files.BothCommands.set(name, mod);
-            mod.alias?.forEach(a => Files.TextCommands.aliases.set(a, mod));
-            return Ok.EMPTY;
+            mod.alias?.forEach(a => insert(ms => ms.TextCommands.set(a, mod)));
+            return insert(ms => ms.BothCommands.set(name, mod));
         })
-        .with({ type: CommandType.MenuUser }, mod => {
-            Files.ApplicationCommands[ApplicationCommandType.User].set(name, mod);
-            return Ok.EMPTY;
-        })
-        .with({ type: CommandType.MenuMsg }, mod => {
-            Files.ApplicationCommands[ApplicationCommandType.Message].set(name, mod);
-            return Ok.EMPTY;
-        })
-        .with({ type: CommandType.Button }, mod => {
-            Files.MessageCompCommands[ComponentType.Button].set(name, mod);
-            return Ok.EMPTY;
-        })
-        .with({ type: CommandType.MenuSelect }, mod => {
-            Files.MessageCompCommands[ComponentType.SelectMenu].set(name, mod);
-            return Ok.EMPTY;
-        })
-        .with({ type: CommandType.Modal }, mod => {
-            Files.ModalSubmitCommands.set(name, mod);
-            return Ok.EMPTY;
-        })
-        .otherwise(() => Err.EMPTY);
+        .with({ type: CommandType.CtxUser }, mod =>
+            insert(ms => ms.ApplicationCommands[ApplicationCommandType.User].set(name, mod)),
+        )
+        .with({ type: CommandType.CtxMsg }, mod =>
+            insert(ms => ms.ApplicationCommands[ApplicationCommandType.Message].set(name, mod)),
+        )
+        .with({ type: CommandType.Button }, mod =>
+            insert(ms => ms.InteractionHandlers[ComponentType.Button].set(name, mod)),
+        )
+        .with({ type: CommandType.StringSelect }, mod =>
+            insert(ms => ms.InteractionHandlers[ComponentType.StringSelect].set(name, mod)),
+        )
+        .with({ type: CommandType.MentionableSelect }, mod =>
+            insert(ms => ms.InteractionHandlers[ComponentType.MentionableSelect].set(name, mod)),
+        )
+        .with({ type: CommandType.ChannelSelect }, mod =>
+            insert(ms => ms.InteractionHandlers[ComponentType.ChannelSelect].set(name, mod)),
+        )
+        .with({ type: CommandType.UserSelect }, mod =>
+            insert(ms => ms.InteractionHandlers[ComponentType.UserSelect].set(name, mod)),
+        )
+        .with({ type: CommandType.RoleSelect }, mod =>
+            insert(ms => ms.InteractionHandlers[ComponentType.RoleSelect].set(name, mod)),
+        )
+        .with({ type: CommandType.Modal }, mod => insert(ms => ms.ModalSubmit.set(name, mod)))
+        .otherwise(err);
 }

src/handler/events/userDefinedEventsHandling.ts

@@ -1,87 +1,124 @@
-import { from, fromEvent, map } from 'rxjs';
-import * as Files from '../utilities/readFile';
-import { buildData, ExternalEventEmitters } from '../utilities/readFile';
+import { catchError, concatMap, filter, from, iif, map, of, tap, toArray } from 'rxjs';
+import { buildData } from '../utilities/readFile';
 import { controller } from '../sern';
-import type {
-    DefinedCommandModule,
-    DefinedEventModule,
-    EventInput,
-    SpreadParams,
-} from '../../types/handler';
-import type { EventModule } from '../structures/module';
-import { PayloadType } from '../structures/enums';
+import type { DefinedCommandModule, DefinedEventModule, Dependencies } from '../../types/handler';
+import { PayloadType, PluginType } from '../structures/enums';
 import type Wrapper from '../structures/wrapper';
-import { basename } from 'path';
+import { isDiscordEvent, isExternalEvent, isSernEvent } from '../utilities/predicates';
+import { errTap, processPlugins, resolvePlugins } from './observableHandling';
+import type { AnyModule, EventModule } from '../../types/module';
+import type { EventEmitter } from 'events';
+import type SernEmitter from '../sernEmitter';
+import { nameOrFilename, reducePlugins } from '../utilities/functions';
 import { match } from 'ts-pattern';
-import { isDiscordEvent, isSernEvent } from '../utilities/predicates';
-import { errTap } from './observableHandling';
+import {
+    discordEventDispatcher,
+    externalEventDispatcher,
+    sernEmitterDispatcher,
+} from './dispatchers';
+import type { ErrorHandling, Logging } from '../contracts';
+import { SernError } from '../structures/errors';
+import { handleError } from '../contracts/errorHandling';
+import type { Awaitable } from 'discord.js';
+import type { Result } from 'ts-results-es';
 
 /**
  * Utility function to process command plugins for all Modules
- * @param wrapper
  * @param payload
  */
-export function processCommandPlugins<T extends DefinedCommandModule>(
-    wrapper: Wrapper,
-    payload: { mod: T; absPath: string },
-) {
+export function processCommandPlugins<
+    T extends DefinedCommandModule | DefinedEventModule,
+>(payload: {
+    mod: T;
+    absPath: string;
+}): { type: PluginType.Command; execute: Awaitable<Result<void, void>> }[] {
     return payload.mod.plugins.map(plug => ({
-        ...plug,
-        name: plug?.name ?? 'Unnamed Plugin',
-        description: plug?.description ?? '...',
-        execute: plug.execute(wrapper, payload, controller),
+        type: plug.type,
+        execute: plug.execute(payload as any, controller),
     }));
 }
 
-export function processEvents(wrapper: Wrapper, events: EventInput) {
-    const eventStream$ = eventObservable$(wrapper, events);
-    const normalize$ = eventStream$.pipe(
-        map(({ mod, absPath }) => {
-            return <DefinedEventModule>{
-                name: mod?.name ?? Files.fmtFileName(basename(absPath)),
-                description: mod?.description ?? '...',
+export function processEvents({ containerConfig, events }: Wrapper) {
+    const [client, error, sernEmitter, logging] = containerConfig.get(
+        '@sern/client',
+        '@sern/errors',
+        '@sern/emitter',
+        '@sern/logger',
+    ) as [EventEmitter, ErrorHandling, SernEmitter, Logging?];
+    const lazy = (k: string) => containerConfig.get(k as keyof Dependencies)[0];
+    const eventStream$ = eventObservable$(events!, sernEmitter);
+    const emitSuccess$ = (mod: AnyModule) =>
+        of({ type: PayloadType.Failure, module: mod, reason: SernError.PluginFailure }).pipe(
+            tap(it => sernEmitter.emit('module.register', it)),
+        );
+    const emitFailure$ = (mod: AnyModule) =>
+        of({ type: PayloadType.Success, module: mod } as const).pipe(
+            tap(it => sernEmitter.emit('module.register', it)),
+        );
+    const eventCreation$ = eventStream$.pipe(
+        map(({ mod, absPath }) => ({
+            mod: {
+                name: nameOrFilename(mod.name, absPath),
                 ...mod,
-            };
-        }),
+            } as DefinedEventModule,
+            absPath,
+        })),
+        concatMap(processPlugins),
+        concatMap(resolvePlugins),
+        //Reduces pluginRes (generated from above) into a single boolean
+        concatMap(({ pluginRes, mod }) =>
+            from(pluginRes).pipe(
+                map(pl => pl.execute),
+                toArray(),
+                reducePlugins,
+                map(success => ({ success, mod })),
+            ),
+        ),
+        concatMap(({ success, mod }) =>
+            iif(() => success, emitFailure$(mod), emitSuccess$(mod)).pipe(
+                filter(res => res.type === PayloadType.Success),
+                map(() => mod),
+            ),
+        ),
     );
-    normalize$.subscribe(e => {
-        const emitter = isSernEvent(e)
-            ? wrapper?.sernEmitter
-            : isDiscordEvent(e)
-            ? wrapper.client
-            : ExternalEventEmitters.get(e.emitter);
-        if (emitter === undefined) {
-            throw new Error(`Cannot find event emitter as it is undefined`);
-        }
-        //Would add sern event emitter for events loaded, attached onto sern emitter, but could lead to unwanted behavior!
-        fromEvent(emitter, e.name, e.execute as SpreadParams<typeof e.execute>).subscribe();
+    eventCreation$.subscribe(e => {
+        const payload = match(e)
+            .when(isSernEvent, sernEmitterDispatcher(sernEmitter))
+            .when(isDiscordEvent, discordEventDispatcher(client))
+            .when(
+                isExternalEvent,
+                externalEventDispatcher(e => lazy(e.emitter)),
+            )
+            .otherwise(() => error.crash(Error(SernError.InvalidModuleType)));
+        payload.execute
+            .pipe(
+                concatMap(({ event, executeEvent }) =>
+                    executeEvent.pipe(
+                        tap(success => {
+                            if (success) {
+                                if (Array.isArray(event)) {
+                                    payload.cmd.execute(...event);
+                                } else {
+                                    payload.cmd.execute(event as never);
+                                }
+                            }
+                        }),
+                        catchError(handleError(error, logging)),
+                    ),
+                ),
+            )
+            .subscribe();
     });
 }
 
-function eventObservable$({ sernEmitter }: Wrapper, events: EventInput) {
-    return match(events)
-        .when(Array.isArray, (arr: { mod: EventModule; absPath: string }[]) => {
-            return from(arr);
-        })
-        .when(
-            e => typeof e === 'string',
-            (eventsDir: string) => {
-                return buildData<EventModule>(eventsDir).pipe(
-                    errTap(reason =>
-                        sernEmitter?.emit('module.register', {
-                            type: PayloadType.Failure,
-                            module: undefined,
-                            reason,
-                        }),
-                    ),
-                );
-            },
-        )
-        .when(
-            e => typeof e === 'function',
-            (evs: () => { mod: EventModule; absPath: string }[]) => {
-                return from(evs());
-            },
-        )
-        .run();
+function eventObservable$(events: string, emitter: SernEmitter) {
+    return buildData<EventModule>(events).pipe(
+        errTap(reason =>
+            emitter.emit('module.register', {
+                type: PayloadType.Failure,
+                module: undefined,
+                reason,
+            }),
+        ),
+    );
 }

src/handler/plugins/plugin.ts

@@ -11,136 +11,99 @@
  * Plugins are reminiscent of middleware in express.
  */
 
-import type { AutocompleteInteraction, Awaitable, Client, ClientEvents } from 'discord.js';
+import type { AutocompleteInteraction, Awaitable, ClientEvents } from 'discord.js';
 import type { Result, Ok, Err } from 'ts-results-es';
-import type { CommandType, DefinitelyDefined, Override, SernEventsMapping } from '../../index';
+import type { CommandType, SernEventsMapping } from '../../index';
 import { EventType, PluginType } from '../../index';
-import type { BaseModule, CommandModuleDefs, EventModuleDefs } from '../structures/module';
-import type { EventEmitter } from 'events';
+import type { CommandModuleDefs, EventModuleDefs } from '../../types/module';
 import type {
     DiscordEventCommand,
     ExternalEventCommand,
     SernEventCommand,
 } from '../structures/events';
-import type SernEmitter from '../sernEmitter';
-import type Wrapper from '../structures/wrapper';
 
 export interface Controller {
     next: () => Ok<void>;
     stop: () => Err<void>;
 }
+export interface Plugin {
+    /** @deprecated will be removed in the next update */
+    name?: string;
+    /** @deprecated will be removed in the next update */
+    description?: string;
+    type: PluginType;
+}
 
-type BasePlugin = Override<
-    BaseModule,
-    {
-        type: PluginType;
-    }
->;
+export interface CommandPlugin<T extends keyof CommandModuleDefs = keyof CommandModuleDefs>
+    extends Plugin {
+    type: PluginType.Command;
+    execute: (
+        payload: {
+            mod: CommandModuleDefs[T] & { name: string; description: string };
+            absPath: string;
+        },
+        controller: Controller,
+    ) => Awaitable<Result<void, void>>;
+}
+export interface DiscordEmitterPlugin extends Plugin {
+    type: PluginType.Command;
+    execute: (
+        payload: { mod: DiscordEventCommand & { name: string }; absPath: string },
+        controller: Controller,
+    ) => Awaitable<Result<void, void>>;
+}
 
-export type CommandPlugin<T extends keyof CommandModuleDefs = keyof CommandModuleDefs> = {
-    [K in T]: Override<
-        BasePlugin,
-        {
-            type: PluginType.Command;
-            execute: (
-                wrapper: Wrapper,
-                payload: {
-                    mod: DefinitelyDefined<CommandModuleDefs[T], 'name' | 'description'>;
-                    absPath: string;
-                },
-                controller: Controller,
-            ) => Awaitable<Result<void, void>>;
-        }
-    >;
-}[T];
+export interface ExternalEmitterPlugin extends Plugin {
+    type: PluginType.Command;
+    execute: (
+        payload: { mod: ExternalEventCommand & { name: string }; absPath: string },
+        controller: Controller,
+    ) => Awaitable<Result<void, void>>;
+}
 
-export type DiscordEmitterPlugin = Override<
-    BasePlugin,
-    {
-        type: PluginType.Command;
-        execute: (
-            wrapper: Client,
-            module: DefinitelyDefined<DiscordEventCommand, 'name' | 'description'>,
-            controller: Controller,
-        ) => Awaitable<Result<void, void>>;
-    }
->;
-export type ExternalEmitterPlugin<T extends EventEmitter = EventEmitter> = Override<
-    BasePlugin,
-    {
-        type: PluginType.Command;
-        execute: (
-            wrapper: T,
-            module: DefinitelyDefined<ExternalEventCommand, 'name' | 'description'>,
-            controller: Controller,
-        ) => Awaitable<Result<void, void>>;
-    }
->;
+export interface SernEmitterPlugin extends Plugin {
+    type: PluginType.Command;
+    execute: (
+        payload: { mod: SernEventCommand & { name: string }; absPath: string },
+        controller: Controller,
+    ) => Awaitable<Result<void, void>>;
+}
 
-export type SernEmitterPlugin = Override<
-    BasePlugin,
-    {
-        type: PluginType.Command;
-        execute: (
-            wrapper: SernEmitter,
-            module: DefinitelyDefined<SernEventCommand, 'name' | 'description'>,
-            controller: Controller,
-        ) => Awaitable<Result<void, void>>;
-    }
->;
+export interface AutocompletePlugin extends Plugin {
+    type: PluginType.Event;
+    execute: (
+        autocmp: AutocompleteInteraction,
+        controlller: Controller,
+    ) => Awaitable<Result<void, void>>;
+}
 
-export type AutocompletePlugin = Override<
-    BaseModule,
-    {
-        type: PluginType.Event;
-        execute: (
-            autocmp: AutocompleteInteraction,
-            controlller: Controller,
-        ) => Awaitable<Result<void, void>>;
-    }
->;
+export interface EventPlugin<K extends keyof CommandModuleDefs = keyof CommandModuleDefs>
+    extends Plugin {
+    type: PluginType.Event;
+    execute: (
+        event: Parameters<CommandModuleDefs[K]['execute']>,
+        controller: Controller,
+    ) => Awaitable<Result<void, void>>;
+}
 
-export type EventPlugin<T extends keyof CommandModuleDefs = keyof CommandModuleDefs> = {
-    [K in T]: Override<
-        BasePlugin,
-        {
-            type: PluginType.Event;
-            execute: (
-                event: Parameters<CommandModuleDefs[K]['execute']>,
-                controller: Controller,
-            ) => Awaitable<Result<void, void>>;
-        }
-    >;
-}[T];
+export interface SernEventPlugin<T extends keyof SernEventsMapping = keyof SernEventsMapping>
+    extends Plugin {
+    name?: T;
+    type: PluginType.Event;
+    execute: (args: SernEventsMapping[T], controller: Controller) => Awaitable<Result<void, void>>;
+}
 
-export type SernEventPlugin<T extends keyof SernEventsMapping = keyof SernEventsMapping> = Override<
-    BasePlugin,
-    {
-        name?: T;
-        type: PluginType.Event;
-        execute: (
-            args: SernEventsMapping[T],
-            controller: Controller,
-        ) => Awaitable<Result<void, void>>;
-    }
->;
+export interface ExternalEventPlugin extends Plugin {
+    type: PluginType.Event;
+    execute: (args: unknown[], controller: Controller) => Awaitable<Result<void, void>>;
+}
 
-export type ExternalEventPlugin = Override<
-    BasePlugin,
-    {
-        type: PluginType.Event;
-        execute: (args: unknown[], controller: Controller) => Awaitable<Result<void, void>>;
-    }
->;
-
-export type DiscordEventPlugin<T extends keyof ClientEvents = keyof ClientEvents> = Override<
-    BasePlugin,
-    {
-        name?: T;
-        type: PluginType.Event;
-        execute: (args: ClientEvents[T], controller: Controller) => Awaitable<Result<void, void>>;
-    }
->;
+export interface DiscordEventPlugin<T extends keyof ClientEvents = keyof ClientEvents>
+    extends Plugin {
+    name?: T;
+    type: PluginType.Event;
+    execute: (args: ClientEvents[T], controller: Controller) => Awaitable<Result<void, void>>;
+}
 
 export type CommandModuleNoPlugins = {
     [T in CommandType]: Omit<CommandModuleDefs[T], 'plugins' | 'onEvent'>;

src/handler/sern.ts

@@ -1,11 +1,8 @@
 import type Wrapper from './structures/wrapper';
-import { Err, Ok } from 'ts-results-es';
-import { ExternalEventEmitters } from './utilities/readFile';
-import type { EventEmitter } from 'events';
 import { processEvents } from './events/userDefinedEventsHandling';
-import type { CommandModule, EventModule } from './structures/module';
-import { EventType, PluginType } from './structures/enums';
+import { CommandType, EventType, PluginType } from './structures/enums';
 import type {
+    Plugin,
     CommandPlugin,
     EventModuleCommandPluginDefs,
     EventModuleEventPluginDefs,
@@ -13,11 +10,20 @@ import type {
     InputCommandModule,
     InputEventModule,
 } from './plugins/plugin';
-import { SernError } from './structures/errors';
 import InteractionHandler from './events/interactionHandler';
 import ReadyHandler from './events/readyHandler';
 import MessageHandler from './events/messageHandler';
-
+import type {
+    CommandModule,
+    CommandModuleDefs,
+    EventModule,
+    EventModuleDefs,
+} from '../types/module';
+import { Container, createContainer } from 'iti';
+import type { Dependencies, OptionalDependencies } from '../types/handler';
+import { composeRoot, containerSubject, useContainer } from './dependencies/provider';
+import type { Logging } from './contracts';
+import { err, ok, partition } from './utilities/functions';
 /**
  *
  * @param wrapper Options to pass into sern.
@@ -25,58 +31,35 @@ import MessageHandler from './events/messageHandler';
  * @example
  * ```ts title="src/index.ts"
  * Sern.init({
- *     client,
  *     defaultPrefix: '!',
  *     commands: 'dist/commands',
+ *     events: 'dist/events',
+ *     containerConfig : {
+ *         get: useContainer
+ *     }
  * })
  * ```
  */
 export function init(wrapper: Wrapper) {
+    const logger = wrapper.containerConfig.get('@sern/logger')[0] as Logging | undefined;
+    const startTime = performance.now();
     const { events } = wrapper;
     if (events !== undefined) {
-        processEvents(wrapper, events);
+        processEvents(wrapper);
     }
     new ReadyHandler(wrapper);
     new MessageHandler(wrapper);
     new InteractionHandler(wrapper);
-}
-
-/**
- *
- * @param emitter Any external event emitter.
- * The object will be stored in a map, and then fetched by the name of the instance's class.
- * As there are infinite possibilities to adding external event emitters,
- * Most types aren't provided and are as narrow as possibly can.
- * @example
- * ```ts title="src/index.ts"
- * //Add this before initiating Sern!
- * Sern.addExternal(new Level())
- * ```
- * @example
- * ```ts title="events/level.ts"
- *  export default eventModule({
- *      emitter: 'Level',
- *      type : EventType.External,
- *      name: 'error',
- *      execute(args) {
- *          console.log(args)
- *      }
- *  })
- * ```
- */
-export function addExternal<T extends EventEmitter>(emitter: T) {
-    if (ExternalEventEmitters.has(emitter.constructor.name)) {
-        throw Error(`${emitter.constructor.name} already exists!`);
-    }
-    ExternalEventEmitters.set(emitter.constructor.name, emitter);
+    const endTime = performance.now();
+    logger?.info({ message: `sern : ${(endTime - startTime).toFixed(2)} ms` });
 }
 
 /**
  * The object passed into every plugin to control a command's behavior
  */
 export const controller = {
-    next: () => Ok.EMPTY,
-    stop: () => Err.EMPTY,
+    next: ok,
+    stop: err,
 };
 
 /**
@@ -84,16 +67,10 @@ export const controller = {
  * @param mod
  */
 export function commandModule(mod: InputCommandModule): CommandModule {
-    const onEvent: EventPlugin[] = [];
-    const plugins: CommandPlugin[] = [];
-    for (const pl of mod.plugins ?? []) {
-        if (pl.type === PluginType.Event) {
-            onEvent.push(pl);
-        } else {
-            plugins.push(pl as CommandPlugin);
-        }
-    }
-
+    const [onEvent, plugins] = partition(
+        mod.plugins ?? [],
+        el => (el as Plugin).type === PluginType.Event,
+    );
     return {
         ...mod,
         onEvent,
@@ -105,17 +82,39 @@ export function commandModule(mod: InputCommandModule): CommandModule {
  * @param mod
  */
 export function eventModule(mod: InputEventModule): EventModule {
-    const onEvent: EventModuleEventPluginDefs[EventType][] = [];
-    const plugins: EventModuleCommandPluginDefs[EventType][] = [];
-    const hasPlugins = mod.plugins && mod.plugins.length > 0;
-    if (hasPlugins) {
-        throw Error(
-            SernError.NotSupportedYet + `: Plugins on event listeners are not supported yet`,
-        );
-    }
+    const [onEvent, plugins] = partition(
+        mod.plugins ?? [],
+        el => (el as Plugin).type === PluginType.Event,
+    );
     return {
         ...mod,
         onEvent,
         plugins,
     } as EventModule;
 }
+/**
+ * @param conf a configuration for creating your project dependencies
+ */
+export function makeDependencies<T extends Dependencies>(conf: {
+    exclude?: Set<OptionalDependencies>;
+    build: (root: Container<Record<string, any>, {}>) => Container<Partial<T>, T>;
+}) {
+    const container = conf.build(createContainer());
+    composeRoot(container, conf.exclude ?? new Set());
+    containerSubject.next(container as unknown as Container<Dependencies, {}>);
+    return useContainer<T>();
+}
+
+export abstract class CommandExecutable<Type extends CommandType> {
+    abstract type: Type;
+    plugins: CommandPlugin<Type>[] = [];
+    onEvent: EventPlugin<Type>[] = [];
+    abstract execute: CommandModuleDefs[Type]['execute'];
+}
+
+export abstract class EventExecutable<Type extends EventType> {
+    abstract type: Type;
+    plugins: EventModuleCommandPluginDefs[Type][] = [];
+    onEvent: EventModuleEventPluginDefs[Type][] = [];
+    abstract execute: EventModuleDefs[Type]['execute'];
+}

src/handler/sernEmitter.ts

@@ -27,7 +27,7 @@ class SernEmitter extends EventEmitter {
     /**
      * Listening to sern events with on. This event stays on until a crash or a normal exit
      * @param eventName
-     * @param args the arguments for emitting the  { eventName }
+     * @param args the arguments for emitting the eventName
      */
     public override emit<T extends keyof SernEventsMapping>(
         eventName: T,

src/handler/structures/context.ts

@@ -1,40 +1,25 @@
-import type { APIGuildMember } from 'discord-api-types/v10';
 import type {
     ChatInputCommandInteraction,
     Client,
-    Guild,
-    GuildMember,
     InteractionReplyOptions,
     Message,
-    ReplyMessageOptions,
     Snowflake,
-    TextBasedChannel,
+    MessageReplyOptions,
     User,
 } from 'discord.js';
-import { type Option, None, Some } from 'ts-results-es';
-import type { Nullish } from '../../types/handler';
+import { Result as Either, Ok as Left, Err as Right } from 'ts-results-es';
+import type { ReplyOptions } from '../../types/handler';
 import { SernError } from './errors';
 
-function firstSome<T>(...args: Option<T>[]): Nullish<T> {
-    for (const op of args) {
-        if (op.some) return op.val;
-    }
-    return null;
+function safeUnwrap<T>(res: Either<T, T>) {
+    return res.val;
 }
-
-//Could I refactor with Either monad?
 /**
  * Provides values shared between
  * Message and ChatInputCommandInteraction
  */
 export default class Context {
-    private constructor(
-        private oMsg: Option<Message> = None,
-        private oInterac: Option<ChatInputCommandInteraction> = None,
-    ) {
-        this.oMsg = oMsg;
-        this.oInterac = oInterac;
-    }
+    private constructor(private ctx: Either<Message, ChatInputCommandInteraction>) {}
 
     /**
      * Getting the Message object. Crashes if module type is
@@ -42,7 +27,7 @@ export default class Context {
      * ChatInputCommandInteraction
      */
     public get message() {
-        return this.oMsg.expect(SernError.MismatchEvent);
+        return this.ctx.expect(SernError.MismatchEvent);
     }
     /**
      * Getting the ChatInputCommandInteraction object. Crashes if module type is
@@ -50,98 +35,72 @@ export default class Context {
      * Message
      */
     public get interaction() {
-        return this.oInterac.expect(SernError.MismatchEvent);
+        return this.ctx.expectErr(SernError.MismatchEvent);
     }
 
     public get id(): Snowflake {
-        return firstSome(
-            this.oInterac.map(i => i.id),
-            this.oMsg.map(m => m.id),
-        )!;
+        return safeUnwrap(this.ctx.map(m => m.id).mapErr(i => i.id));
     }
 
-    public get channel(): Nullish<TextBasedChannel> {
-        return firstSome(
-            this.oMsg.map(m => m.channel),
-            this.oInterac.map(i => i.channel),
-        );
+    public get channel() {
+        return safeUnwrap(this.ctx.map(m => m.channel).mapErr(i => i.channel));
     }
-
+    /**
+     * If context is holding a message, message.author
+     * else, interaction.user
+     */
     public get user(): User {
-        return firstSome(
-            this.oMsg.map(m => m.author),
-            this.oInterac.map(i => i.user),
-        )!;
+        return safeUnwrap(this.ctx.map(m => m.author).mapErr(i => i.user));
     }
 
     public get createdTimestamp(): number {
-        return firstSome(
-            this.oMsg.map(m => m.createdTimestamp),
-            this.oInterac.map(i => i.createdTimestamp),
-        )!;
+        return safeUnwrap(this.ctx.map(m => m.createdTimestamp).mapErr(i => i.createdTimestamp));
     }
 
-    public get guild(): Guild {
-        return firstSome(
-            this.oMsg.map(m => m.guild),
-            this.oInterac.map(i => i.guild),
-        )!;
+    public get guild() {
+        return safeUnwrap(this.ctx.map(m => m.guild).mapErr(i => i.guild));
     }
 
-    public get guildId(): Snowflake {
-        return firstSome(
-            this.oMsg.map(m => m.guildId),
-            this.oInterac.map(i => i.guildId),
-        )!;
+    public get guildId() {
+        return safeUnwrap(this.ctx.map(m => m.guildId).mapErr(i => i.guildId));
     }
 
     /*
      * interactions can return APIGuildMember if the guild it is emitted from is not cached
      */
-    public get member(): Nullish<GuildMember | APIGuildMember> {
-        return firstSome(
-            this.oMsg.map(m => m.member),
-            this.oInterac.map(i => i.member),
-        );
+    public get member() {
+        return safeUnwrap(this.ctx.map(m => m.member).mapErr(i => i.member));
     }
 
     public get client(): Client {
-        return firstSome(
-            this.oMsg.map(m => m.client),
-            this.oInterac.map(i => i.client),
-        )!;
+        return safeUnwrap(this.ctx.map(m => m.client).mapErr(i => i.client));
     }
 
     public get inGuild(): boolean {
-        return firstSome(
-            this.oMsg.map(m => m.inGuild()),
-            this.oInterac.map(i => i.inGuild()),
-        )!;
+        return safeUnwrap(this.ctx.map(m => m.inGuild()).mapErr(i => i.inGuild()));
+    }
+    public isMessage() {
+        return this.ctx.map(() => true).unwrapOr(false);
+    }
+
+    public isSlash() {
+        return !this.isMessage();
     }
 
     static wrap(wrappable: ChatInputCommandInteraction | Message): Context {
         if ('token' in wrappable) {
-            return new Context(None, Some(wrappable));
+            return new Context(Right(wrappable));
         }
-        return new Context(Some(wrappable), None);
+        return new Context(Left(wrappable));
     }
 
-    public isEmpty() {
-        return this.oMsg.none && this.oInterac.none;
-    }
-    //Make queueable
-    public reply(
-        content: string | Omit<InteractionReplyOptions, 'fetchReply'> | ReplyMessageOptions,
-    ) {
-        return firstSome(
-            this.oInterac.map(i => {
-                return i
-                    .reply(content as string | InteractionReplyOptions)
-                    .then(() => i.fetchReply());
-            }),
-            this.oMsg.map(m => {
-                return m.reply(content as string | ReplyMessageOptions);
-            }),
-        )!;
+    public reply(content: ReplyOptions) {
+        return safeUnwrap(
+            this.ctx
+                .map(m => m.reply(content as string | MessageReplyOptions))
+                .mapErr(i =>
+                    i.reply(content as string | InteractionReplyOptions).then(() => i.fetchReply()),
+                ),
+        );
     }
 }

src/handler/structures/enums.ts

@@ -1,4 +1,5 @@
 /**
+ * A bitfield that discriminates command modules
  * @enum { number }
  * @example
  * ```ts
@@ -16,38 +17,46 @@ export enum CommandType {
     /**
      * The CommandType for text commands
      */
-    Text = 0b00000000001,
+    Text = 1,
     /**
      * The CommandType for slash commands
      */
-    Slash = 0b00000000010,
+    Slash = 2,
     /**
      * The CommandType for hybrid commands, text and slash
      */
-    Both = 0b0000011,
+    Both = 3,
     /**
      * The CommandType for UserContextMenuInteraction commands
      */
-    MenuUser = 0b00000000100,
+    CtxUser = 4,
     /**
      * The CommandType for MessageContextMenuInteraction commands
      */
-    MenuMsg = 0b0000001000,
+    CtxMsg = 8,
     /**
      * The CommandType for ButtonInteraction commands
      */
-    Button = 0b00000010000,
+    Button = 16,
     /**
-     * The CommandType for SelectMenuInteraction commands
+     * The CommandType for StringSelectMenuInteraction commands
      */
-    MenuSelect = 0b00000100000,
+    StringSelect = 32,
     /**
      * The CommandType for ModalSubmitInteraction commands
      */
-    Modal = 0b00001000000,
+    Modal = 64,
+    /**
+     * The CommandType for the other SelectMenuInteractions
+     */
+    ChannelSelect = 256,
+    MentionableSelect = 512,
+    RoleSelect = 1024,
+    UserSelect = 2048,
 }
 
 /**
+ * A bitfield that discriminates event modules
  * @enum { number }
  * @example
  * ```ts
@@ -65,19 +74,20 @@ export enum EventType {
     /**
      * The EventType for handling discord events
      */
-    Discord = 0b01,
+    Discord = 1,
     /**
      * The EventType for handling sern events
      */
-    Sern = 0b10,
+    Sern = 2,
     /**
      * The EventType for handling external events.
      * Could be for example, `process` events, database events
      */
-    External = 0b11,
+    External = 3,
 }
 
 /**
+ * A bitfield that discriminates plugins
  * @enum { number }
  * @example
  * ```ts
@@ -94,11 +104,11 @@ export enum PluginType {
     /**
      * The PluginType for CommandPlugins
      */
-    Command = 0b01,
+    Command = 1,
     /**
      * The PluginType for EventPlugins
      */
-    Event = 0b10,
+    Event = 2,
 }
 /**
  * @enum { string }

src/handler/structures/errors.ts

@@ -31,4 +31,8 @@ export enum SernError {
      * Unsupported feature attempted to access at this time
      */
     NotSupportedYet = `This feature is not supported yet`,
+    /**
+     * Required Dependency not found
+     */
+    MissingRequired = `@sern/client is required but was not found`,
 }

src/handler/structures/events.ts

@@ -1,5 +1,4 @@
-import type { Override, SernEventsMapping } from '../../types/handler';
-import type { BaseModule } from './module';
+import type { SernEventsMapping } from '../../types/handler';
 import type {
     DiscordEmitterPlugin,
     DiscordEventPlugin,
@@ -10,44 +9,31 @@ import type {
 } from '../plugins/plugin';
 import type { Awaitable, ClientEvents } from 'discord.js';
 import type { EventType } from './enums';
+import type { Module } from '../../types/module';
 
-/*
- * Mapped type to generate all sern event modules
- */
-export type SernEventCommand<T extends keyof SernEventsMapping = keyof SernEventsMapping> =
-    Override<
-        BaseModule,
-        {
-            name?: T;
-            type: EventType.Sern;
-            onEvent: SernEventPlugin[];
-            plugins: SernEmitterPlugin[];
-            execute(...args: SernEventsMapping[T]): Awaitable<void | unknown>;
-        }
-    >;
-/*
- * Mapped type to generate all discord event modules
- */
-export type DiscordEventCommand<T extends keyof ClientEvents = keyof ClientEvents> = Override<
-    BaseModule,
-    {
-        name?: T;
-        type: EventType.Discord;
-        onEvent: DiscordEventPlugin[];
-        plugins: DiscordEmitterPlugin[];
-        execute(...args: ClientEvents[T]): Awaitable<void | unknown>;
-    }
->;
-/*
- * Type for any event emitter that can be handled by sern
- */
-export type ExternalEventCommand = Override<
-    BaseModule,
-    {
-        emitter: string;
-        type: EventType.External;
-        onEvent: ExternalEventPlugin[];
-        plugins: ExternalEmitterPlugin[];
-        execute(...args: unknown[]): Awaitable<void | unknown>;
-    }
->;
+export interface SernEventCommand<T extends keyof SernEventsMapping = keyof SernEventsMapping>
+    extends Module {
+    name?: T;
+    type: EventType.Sern;
+    onEvent: SernEventPlugin[];
+    plugins: SernEmitterPlugin[];
+    execute(...args: SernEventsMapping[T]): Awaitable<unknown>;
+}
+
+export interface DiscordEventCommand<T extends keyof ClientEvents = keyof ClientEvents>
+    extends Module {
+    name?: T;
+    type: EventType.Discord;
+    onEvent: DiscordEventPlugin[];
+    plugins: DiscordEmitterPlugin[];
+    execute(...args: ClientEvents[T]): Awaitable<unknown>;
+}
+
+export interface ExternalEventCommand extends Module {
+    name?: string;
+    emitter: string;
+    type: EventType.External;
+    onEvent: ExternalEventPlugin[];
+    plugins: ExternalEmitterPlugin[];
+    execute(...args: unknown[]): Awaitable<unknown>;
+}

src/handler/structures/module.ts

@@ -1,210 +0,0 @@
-import type {
-    ApplicationCommandAttachmentOption,
-    ApplicationCommandChannelOptionData,
-    ApplicationCommandChoicesData,
-    ApplicationCommandNonOptionsData,
-    ApplicationCommandNumericOptionData,
-    ApplicationCommandOptionData,
-    ApplicationCommandOptionType,
-    ApplicationCommandSubCommandData,
-    ApplicationCommandSubGroupData,
-    AutocompleteInteraction,
-    Awaitable,
-    BaseApplicationCommandOptionsData,
-    ButtonInteraction,
-    MessageContextMenuCommandInteraction,
-    ModalSubmitInteraction,
-    SelectMenuInteraction,
-    UserContextMenuCommandInteraction,
-} from 'discord.js';
-import type { Args, Override, SlashOptions } from '../../types/handler';
-import type { AutocompletePlugin, CommandPlugin, EventPlugin } from '../plugins/plugin';
-import type Context from './context';
-import { CommandType, EventType, PluginType } from './enums';
-import type { DiscordEventCommand, ExternalEventCommand, SernEventCommand } from './events';
-
-export interface BaseModule {
-    type: CommandType | PluginType;
-    name?: string;
-    description?: string;
-    execute: (ctx: Context, args: Args) => Awaitable<void | unknown>;
-}
-
-export type TextCommand = Override<
-    BaseModule,
-    {
-        type: CommandType.Text;
-        onEvent: EventPlugin<CommandType.Text>[]; //maybe allow BothPlugins for this also?
-        plugins: CommandPlugin[]; //maybe allow BothPlugins for this also?
-        alias?: string[];
-        execute: (ctx: Context, args: ['text', string[]]) => Awaitable<void | unknown>;
-    }
->;
-
-export type SlashCommand = Override<
-    BaseModule,
-    {
-        type: CommandType.Slash;
-        onEvent: EventPlugin<CommandType.Slash>[]; //maybe allow BothPlugins for this also?
-        plugins: CommandPlugin[]; //maybe allow BothPlugins for this also?
-        options?: SernOptionsData[];
-        execute: (ctx: Context, args: ['slash', SlashOptions]) => Awaitable<void | unknown>;
-    }
->;
-
-export type BothCommand = Override<
-    BaseModule,
-    {
-        type: CommandType.Both;
-        onEvent: EventPlugin<CommandType.Both>[];
-        plugins: CommandPlugin[];
-        alias?: string[];
-        options?: SernOptionsData[];
-        execute: (ctx: Context, args: Args) => Awaitable<void | unknown>;
-    }
->;
-
-export type ContextMenuUser = Override<
-    BaseModule,
-    {
-        type: CommandType.MenuUser;
-        onEvent: EventPlugin<CommandType.MenuUser>[];
-        plugins: CommandPlugin[];
-        execute: (ctx: UserContextMenuCommandInteraction) => Awaitable<void | unknown>;
-    }
->;
-
-export type ContextMenuMsg = Override<
-    BaseModule,
-    {
-        type: CommandType.MenuMsg;
-        onEvent: EventPlugin<CommandType.MenuMsg>[];
-        plugins: CommandPlugin[];
-        execute: (ctx: MessageContextMenuCommandInteraction) => Awaitable<void | unknown>;
-    }
->;
-
-export type ButtonCommand = Override<
-    BaseModule,
-    {
-        type: CommandType.Button;
-        onEvent: EventPlugin<CommandType.Button>[];
-        plugins: CommandPlugin[];
-        execute: (ctx: ButtonInteraction) => Awaitable<void | unknown>;
-    }
->;
-
-export type SelectMenuCommand = Override<
-    BaseModule,
-    {
-        type: CommandType.MenuSelect;
-        onEvent: EventPlugin<CommandType.MenuSelect>[];
-        plugins: CommandPlugin[];
-        execute: (ctx: SelectMenuInteraction) => Awaitable<void | unknown>;
-    }
->;
-
-export type ModalSubmitCommand = Override<
-    BaseModule,
-    {
-        type: CommandType.Modal;
-        onEvent: EventPlugin<CommandType.Modal>[];
-        plugins: CommandPlugin[];
-        execute: (ctx: ModalSubmitInteraction) => Awaitable<void | unknown>;
-    }
->;
-
-// Autocomplete commands are a little different
-// They can't have command plugins as they are
-// in conjunction with chat input commands
-export type AutocompleteCommand = Override<
-    BaseModule,
-    {
-        name?: never;
-        description?: never;
-        type?: never;
-        onEvent: AutocompletePlugin[];
-        execute: (ctx: AutocompleteInteraction) => Awaitable<void | unknown>;
-    }
->;
-export type EventModule = DiscordEventCommand | SernEventCommand | ExternalEventCommand;
-export type CommandModule =
-    | TextCommand
-    | SlashCommand
-    | BothCommand
-    | ContextMenuUser
-    | ContextMenuMsg
-    | ButtonCommand
-    | SelectMenuCommand
-    | ModalSubmitCommand;
-
-export type Module = CommandModule | EventModule;
-
-//https://stackoverflow.com/questions/64092736/alternative-to-switch-statement-for-typescript-discriminated-union
-// Explicit Module Definitions for mapping
-export type CommandModuleDefs = {
-    [CommandType.Text]: TextCommand;
-    [CommandType.Slash]: SlashCommand;
-    [CommandType.Both]: BothCommand;
-    [CommandType.MenuMsg]: ContextMenuMsg;
-    [CommandType.MenuUser]: ContextMenuUser;
-    [CommandType.Button]: ButtonCommand;
-    [CommandType.MenuSelect]: SelectMenuCommand;
-    [CommandType.Modal]: ModalSubmitCommand;
-};
-
-export type EventModuleDefs = {
-    [EventType.Sern]: SernEventCommand;
-    [EventType.Discord]: DiscordEventCommand;
-    [EventType.External]: ExternalEventCommand;
-};
-
-//TODO: support deeply nested Autocomplete
-// objective: construct union of ApplicationCommandOptionData change any Autocomplete data
-// into Sern autocomplete data.
-
-export type SernAutocompleteData = Override<
-    BaseApplicationCommandOptionsData,
-    {
-        autocomplete: true;
-        type:
-            | ApplicationCommandOptionType.String
-            | ApplicationCommandOptionType.Number
-            | ApplicationCommandOptionType.Integer;
-        command: AutocompleteCommand;
-    }
->;
-
-/**
- * Type that replaces autocomplete with {@link SernAutocompleteData}
- */
-export type BaseOptions =
-    | ApplicationCommandChoicesData
-    | ApplicationCommandNonOptionsData
-    | ApplicationCommandChannelOptionData
-    | ApplicationCommandNumericOptionData
-    | ApplicationCommandAttachmentOption
-    | SernAutocompleteData;
-
-export type SernSubCommandData = Override<
-    Omit<BaseApplicationCommandOptionsData, 'required'>,
-    {
-        type: ApplicationCommandOptionType.Subcommand;
-        options?: BaseOptions[];
-    }
->;
-
-export type SernSubCommandGroupData = Override<
-    Omit<BaseApplicationCommandOptionsData, 'required'>,
-    {
-        type: ApplicationCommandOptionType.SubcommandGroup;
-        options?: SernSubCommandData[];
-    }
->;
-
-export type SernOptionsData<U extends ApplicationCommandOptionData = ApplicationCommandOptionData> =
-    U extends ApplicationCommandSubCommandData
-        ? SernSubCommandData
-        : U extends ApplicationCommandSubGroupData
-        ? SernSubCommandGroupData
-        : BaseOptions;

src/handler/structures/moduleStore.ts

@@ -0,0 +1,25 @@
+import type { CommandModule } from '../../types/module';
+import { ApplicationCommandType, ComponentType } from 'discord.js';
+
+/**
+ * Storing all command modules
+ * This dependency is usually injected into ModuleManager
+ */
+export class ModuleStore {
+    readonly BothCommands = new Map<string, CommandModule>();
+    readonly ApplicationCommands = {
+        [ApplicationCommandType.User]: new Map<string, CommandModule>(),
+        [ApplicationCommandType.Message]: new Map<string, CommandModule>(),
+        [ApplicationCommandType.ChatInput]: new Map<string, CommandModule>(),
+    };
+    readonly ModalSubmit = new Map<string, CommandModule>();
+    readonly TextCommands = new Map<string, CommandModule>();
+    readonly InteractionHandlers = {
+        [ComponentType.Button]: new Map<string, CommandModule>(),
+        [ComponentType.StringSelect]: new Map<string, CommandModule>(),
+        [ComponentType.ChannelSelect]: new Map<string, CommandModule>(),
+        [ComponentType.MentionableSelect]: new Map<string, CommandModule>(),
+        [ComponentType.RoleSelect]: new Map<string, CommandModule>(),
+        [ComponentType.UserSelect]: new Map<string, CommandModule>(),
+    };
+}

src/handler/structures/structxports.ts

@@ -1,28 +1,6 @@
 import Context from './context';
-import type {
-    BothCommand,
-    Module,
-    SlashCommand,
-    TextCommand,
-    SernOptionsData,
-    BaseOptions,
-    SernAutocompleteData,
-    SernSubCommandData,
-    SernSubCommandGroupData,
-} from './module';
 import type Wrapper from './wrapper';
+import { ModuleStore } from './moduleStore';
 
 export * from './enums';
-export {
-    Context,
-    SlashCommand,
-    TextCommand,
-    BothCommand,
-    Module,
-    Wrapper,
-    SernOptionsData,
-    BaseOptions,
-    SernAutocompleteData,
-    SernSubCommandData,
-    SernSubCommandGroupData,
-};
+export { Context, Wrapper, ModuleStore };

src/handler/structures/wrapper.ts

@@ -1,20 +1,15 @@
-import type { Client } from 'discord.js';
-import type SernEmitter from '../sernEmitter';
-import type { EventModule } from './module';
+import type { Dependencies } from '../../types/handler';
 
 /**
  * An object to be passed into Sern#init() function.
  * @typedef {object} Wrapper
  */
 interface Wrapper {
-    readonly client: Client;
-    readonly sernEmitter?: SernEmitter;
     readonly defaultPrefix?: string;
     readonly commands: string;
-    readonly events?:
-        | string
-        | { mod: EventModule; absPath: string }[]
-        | (() => { mod: EventModule; absPath: string }[]);
+    readonly events?: string;
+    readonly containerConfig: {
+        get: (...keys: (keyof Dependencies)[]) => unknown[];
+    };
 }
-
 export default Wrapper;

src/handler/utilities/arrAsync.ts

@@ -1,6 +1,6 @@
 import type { Awaitable } from 'discord.js';
 
-export async function asyncResolveArray<T>(promiseLike: Awaitable<T>[]): Promise<T[]> {
+export async function arrAsync<T>(promiseLike: Awaitable<T>[]): Promise<T[]> {
     const arr: T[] = [];
     for await (const el of promiseLike) {
         arr.push(el);

src/handler/utilities/functions.ts

@@ -0,0 +1,47 @@
+import * as Files from './readFile';
+import { basename } from 'path';
+import { Err, Ok, Result } from 'ts-results-es';
+import { Observable, of, switchMap } from 'rxjs';
+/**
+ * A function that returns whatever value is provided.
+ * Used for singleton in iti
+ * @param value
+ */
+export const _const =
+    <T>(value: T) =>
+    () =>
+        value;
+/**
+ * A function that returns another function
+ * Used for transient in iti
+ * @param value
+ */
+export const transient =
+    <T>(value: T) =>
+    () =>
+        _const(value);
+
+export function nameOrFilename(modName: string | undefined, absPath: string) {
+    return modName ?? Files.fmtFileName(basename(absPath));
+}
+
+//function wrappers for empty ok / err
+export const ok = _const(Ok.EMPTY);
+export const err = _const(Err.EMPTY);
+
+export function partition<T, V>(arr: (T & V)[], condition: (e: T & V) => boolean): [T[], V[]] {
+    const t: T[] = [];
+    const v: V[] = [];
+    for (const el of arr) {
+        if (condition(el)) {
+            t.push(el as T);
+        } else {
+            v.push(el as V);
+        }
+    }
+    return [t, v];
+}
+
+export function reducePlugins(src: Observable<Result<void, void>[]>): Observable<boolean> {
+    return src.pipe(switchMap(s => of(s.every(a => a.ok))));
+}

src/handler/utilities/predicates.ts

@@ -1,24 +1,13 @@
-import type { CommandModuleDefs, EventModule, Module } from '../structures/module';
-import {
-    AutocompleteInteraction,
-    Interaction,
-    InteractionType,
-    type ModalSubmitInteraction,
-    type ButtonInteraction,
-    type SelectMenuInteraction,
-    type ChatInputCommandInteraction,
-    type UserContextMenuCommandInteraction,
-    type MessageContextMenuCommandInteraction,
-} from 'discord.js';
 import type {
     DiscordEventCommand,
     ExternalEventCommand,
     SernEventCommand,
 } from '../structures/events';
-import { EventType } from '../..';
+import { CommandModule, EventType } from '../..';
+import type { AnyModule, CommandModuleDefs, EventModule } from '../../types/module';
 
 export function correctModuleType<T extends keyof CommandModuleDefs>(
-    plug: Module | undefined,
+    plug: AnyModule | undefined,
     type: T,
 ): plug is CommandModuleDefs[T] {
     // Another way to check if type is equivalent,
@@ -26,45 +15,12 @@ export function correctModuleType<T extends keyof CommandModuleDefs>(
     return plug !== undefined && (plug.type & type) !== 0;
 }
 
-export function isApplicationCommand(
-    interaction: Interaction,
-): interaction is
-    | ChatInputCommandInteraction
-    | UserContextMenuCommandInteraction
-    | MessageContextMenuCommandInteraction {
-    return interaction.type === InteractionType.ApplicationCommand;
-}
-
-export function isModalSubmit(interaction: Interaction): interaction is ModalSubmitInteraction {
-    return interaction.type === InteractionType.ModalSubmit;
-}
-export function isAutocomplete(interaction: Interaction): interaction is AutocompleteInteraction {
-    return interaction.type === InteractionType.ApplicationCommandAutocomplete;
-}
-export function isMessageComponent(
-    interaction: Interaction,
-): interaction is ButtonInteraction | SelectMenuInteraction {
-    return interaction.type === InteractionType.MessageComponent;
-}
-
-export function isDiscordEvent(el: EventModule): el is DiscordEventCommand {
+export function isDiscordEvent(el: EventModule | CommandModule): el is DiscordEventCommand {
     return el.type === EventType.Discord;
 }
-export function isSernEvent(el: EventModule): el is SernEventCommand {
+export function isSernEvent(el: EventModule | CommandModule): el is SernEventCommand {
     return el.type === EventType.Sern;
 }
-
-export function isExternalEvent(el: EventModule): el is ExternalEventCommand {
+export function isExternalEvent(el: EventModule | CommandModule): el is ExternalEventCommand {
     return el.type === EventType.External && 'emitter' in el;
 }
-
-// export function isEventPlugin<T extends CommandType>(
-//     e: CommandModulePlugin<T>,
-// ): e is EventPlugin<T> {
-//     return e.type === PluginType.Event;
-// }
-// export function isCommandPlugin<T extends CommandType>(
-//     e: CommandModulePlugin<T>,
-// ): e is CommandPlugin<T> {
-//     return !isEventPlugin(e);
-// }

src/handler/utilities/readFile.ts

@@ -1,34 +1,8 @@
-import { ApplicationCommandType, ComponentType } from 'discord.js';
 import { readdirSync, statSync } from 'fs';
 import { join } from 'path';
-import  { type Observable, from, concatAll } from 'rxjs';
-import type { CommandModule } from '../structures/module';
+import { type Observable, from, concatAll } from 'rxjs';
 import { SernError } from '../structures/errors';
 import { type Result, Err, Ok } from 'ts-results-es';
-import type { EventEmitter } from 'events';
-
-//Maybe move this? this probably doesnt belong in utlities/
-export const BothCommands = new Map<string, CommandModule>();
-export const ApplicationCommands = {
-    [ApplicationCommandType.User]: new Map<string, CommandModule>(),
-    [ApplicationCommandType.Message]: new Map<string, CommandModule>(),
-    [ApplicationCommandType.ChatInput]: new Map<string, CommandModule>(),
-} as { [K in ApplicationCommandType]: Map<string, CommandModule> };
-
-export const MessageCompCommands = {
-    [ComponentType.Button]: new Map<string, CommandModule>(),
-    [ComponentType.SelectMenu]: new Map<string, CommandModule>(),
-    [ComponentType.TextInput]: new Map<string, CommandModule>(),
-};
-export const TextCommands = {
-    text: new Map<string, CommandModule>(),
-    aliases: new Map<string, CommandModule>(),
-};
-export const ModalSubmitCommands = new Map<string, CommandModule>();
-/**
- * keeps all external emitters stored here
- */
-export const ExternalEventEmitters = new Map<string, EventEmitter>();
 
 // Courtesy @Townsy45
 function readPath(dir: string, arrayOfFiles: string[] = []): string[] {
@@ -63,19 +37,26 @@ export function buildData<T>(commandDir: string): Observable<
     >
 > {
     const commands = getCommands(commandDir);
-    return from(Promise.all(commands.map(async absPath => {
-            let mod : T | undefined;
-            try {
-                // eslint-disable-next-line @typescript-eslint/no-var-requires
-                mod = require(absPath).default;
-            } catch {
-                mod = (await import(`file:///` +absPath)).default;
-            }
-            if (mod !== undefined) {
+    return from(
+        Promise.all(
+            commands.map(async absPath => {
+                let mod: T | undefined;
+                try {
+                    // eslint-disable-next-line @typescript-eslint/no-var-requires
+                    mod = require(absPath).default;
+                } catch {
+                    mod = (await import(`file:///` + absPath)).default;
+                }
+                if (mod === undefined) {
+                    return Err(SernError.UndefinedModule);
+                }
+                try {
+                    mod = new (mod as unknown as new () => T)();
+                } catch {}
                 return Ok({ mod, absPath });
-            } else return Err(SernError.UndefinedModule);
-        })
-    )).pipe(concatAll());
+            }),
+        ),
+    ).pipe(concatAll());
 }
 
 export function getCommands(dir: string): string[] {

src/handler/utilities/treeSearch.ts

@@ -1,31 +1,42 @@
-import type { SernOptionsData } from '../structures/module';
 import { ApplicationCommandOptionType, AutocompleteInteraction } from 'discord.js';
+import type { SernAutocompleteData, SernOptionsData } from '../../types/module';
 
-export default function treeSearch(iAutocomplete: AutocompleteInteraction, options: SernOptionsData[] | undefined) {
-    if(options === undefined) return undefined;
+export default function treeSearch(
+    iAutocomplete: AutocompleteInteraction,
+    options: SernOptionsData[] | undefined,
+): SernAutocompleteData | undefined {
+    if (options === undefined) return undefined;
     const _options = options.slice(); // required to prevent direct mutation of options
-    while ( _options.length > 0 ) {
+    let autocompleteData: SernAutocompleteData | undefined;
+
+    while (_options.length > 0) {
         const cur = _options.pop()!;
-        switch ( cur.type ) {
-            case ApplicationCommandOptionType.Subcommand : {
-                for ( const option of cur.options ?? [] ) {
-                    _options.push(option);
-                }
-            } break;
-            case ApplicationCommandOptionType.SubcommandGroup : {
-                for (const command of cur.options ?? []) {
-                    _options.push(command);
-                }
-            } break;
-            default : {
-                if(cur.autocomplete) {
-                    const choice = iAutocomplete.options.getFocused(true);
-                    if(cur.name === choice.name && cur.autocomplete) {
-                        return cur;
+        switch (cur.type) {
+            case ApplicationCommandOptionType.Subcommand:
+                {
+                    for (const option of cur.options ?? []) {
+                        _options.push(option);
                     }
-                        return undefined;
                 }
-            } break;
+                break;
+            case ApplicationCommandOptionType.SubcommandGroup:
+                {
+                    for (const command of cur.options ?? []) {
+                        _options.push(command);
+                    }
+                }
+                break;
+            default:
+                {
+                    if (cur.autocomplete) {
+                        const choice = iAutocomplete.options.getFocused(true);
+                        if (cur.name === choice.name && cur.autocomplete) {
+                            autocompleteData = cur;
+                        }
+                    }
+                }
+                break;
         }
     }
-}
+    return autocompleteData;
+}

src/index.ts

@@ -1,7 +1,11 @@
 import SernEmitter from './handler/sernEmitter';
-export { eventModule, commandModule } from './handler/sern';
+export { eventModule, commandModule, EventExecutable, CommandExecutable } from './handler/sern';
 export * as Sern from './handler/sern';
 export * from './types/handler';
+export * from './types/module';
 export * from './handler/structures/structxports';
 export * from './handler/plugins/plugin';
+export * from './handler/contracts/index';
 export { SernEmitter };
+export { _const as single, transient as many } from './handler/utilities/functions';
+export { useContainerRaw } from './handler/dependencies/provider';

src/types/handler.ts

@@ -1,8 +1,12 @@
 import type { CommandInteractionOptionResolver } from 'discord.js';
-import type { CommandModule, EventModule, Module } from '../handler/structures/module';
 import type { PayloadType } from '../handler/structures/enums';
-export type Nullish<T> = T | undefined | null;
-
+import type { InteractionReplyOptions, MessageReplyOptions } from 'discord.js';
+import type { EventEmitter } from 'events';
+import type { CommandModule, EventModule, AnyModule } from './module';
+import type { UnpackFunction } from 'iti';
+import type { ErrorHandling, Logging, ModuleManager } from '../handler/contracts';
+import type { ModuleStore } from '../handler/structures/moduleStore';
+import type SernEmitter from '../handler/sernEmitter';
 // Thanks to @kelsny
 export type ParseType<T> = {
     [K in keyof T]: T[K] extends unknown ? [k: K, args: T[K]] : never;
@@ -12,47 +16,49 @@ export type Args = ParseType<{ text: string[]; slash: SlashOptions }>;
 
 export type SlashOptions = Omit<CommandInteractionOptionResolver, 'getMessage' | 'getFocused'>;
 
-// Source: https://dev.to/vborodulin/ts-how-to-override-properties-with-type-intersection-554l
-export type Override<T1, T2> = Omit<T1, keyof T2> & T2;
-
-export type DefinitelyDefined<T, K extends keyof T = keyof T> = {
-    [L in K]-?: T[L] extends Record<string, unknown>
-        ? DefinitelyDefined<T[L], keyof T[L]>
-        : Required<T>[L];
-} & T;
-
-export type EventInput =
-    | string
-    | { mod: EventModule; absPath: string }[]
-    | (() => { mod: EventModule; absPath: string }[]);
-
-export type Reconstruct<T> = T extends Omit<infer O, never> ? O & Reconstruct<O> : T;
-
-export type IsOptional<T> = {
-    [K in keyof T]-?: T[K] extends Required<T>[K] ? false : true;
-};
-
-/**
- * Turns a function with a union of array of args into a single union
- *  [ T , V , B ] | [ A ] => T | V | B | A
- */
-export type SpreadParams<T extends (...args: never) => unknown> = (
-    args: Parameters<T>[number],
-) => unknown;
-
 /**
  * After modules are transformed, name and description are given default values if none
  * are provided to Module. This type represents that transformation
  */
-export type DefinedModule = DefinitelyDefined<Module, 'name' | 'description'>;
-export type DefinedCommandModule = DefinitelyDefined<CommandModule, 'name' | 'description'>;
-export type DefinedEventModule = DefinitelyDefined<EventModule, 'name' | 'description'>;
+export type DefinedCommandModule = CommandModule & { name: string; description: string };
+export type DefinedEventModule = EventModule & { name: string };
+export type AnyDefinedModule = DefinedCommandModule | DefinedEventModule;
 export type Payload =
-    | { type: PayloadType.Success; module: Module }
-    | { type: PayloadType.Failure; module: Module | undefined; reason: string | Error };
+    | { type: PayloadType.Success; module: AnyModule }
+    | { type: PayloadType.Failure; module?: AnyModule; reason: string | Error }
+    | { type: PayloadType.Warning; reason: string };
 export type SernEventsMapping = {
-    ['module.register']: [Payload];
-    ['module.activate']: [Payload];
-    ['error']: [Error | string];
-    ['warning']: [string];
+    'module.register': [Payload];
+    'module.activate': [Payload];
+    error: [Payload];
+    warning: [Payload];
 };
+export type LogPayload<T = unknown> = { message: T };
+export type Singleton<T> = () => T;
+export type Transient<T> = () => () => T;
+
+export interface Dependencies {
+    '@sern/client': Singleton<EventEmitter>;
+    '@sern/logger'?: Singleton<Logging>;
+    '@sern/emitter': Singleton<SernEmitter>;
+    '@sern/store': Singleton<ModuleStore>;
+    '@sern/modules': Singleton<ModuleManager>;
+    '@sern/errors': Singleton<ErrorHandling>;
+}
+
+export type ReplyOptions =
+    | string
+    | Omit<InteractionReplyOptions, 'fetchReply'>
+    | MessageReplyOptions;
+
+export type MapDeps<Deps extends Dependencies, T extends readonly unknown[]> = T extends [
+    infer First extends keyof Deps,
+    ...infer Rest extends readonly unknown[],
+]
+    ? [
+          UnpackFunction<Deps[First]>,
+          ...(MapDeps<Deps, Rest> extends [never] ? [] : MapDeps<Deps, Rest>),
+      ]
+    : [never];
+//Basically, '@sern/client' | '@sern/store' | '@sern/modules' | '@sern/error' | '@sern/emitter' will be provided defaults, and you can exclude the rest
+export type OptionalDependencies = '@sern/logger';

src/types/module.ts

@@ -0,0 +1,216 @@
+import type {
+    ApplicationCommandAttachmentOption,
+    ApplicationCommandChannelOptionData,
+    ApplicationCommandChoicesData,
+    ApplicationCommandNonOptionsData,
+    ApplicationCommandNumericOptionData,
+    ApplicationCommandOptionData,
+    ApplicationCommandOptionType,
+    ApplicationCommandSubCommandData,
+    ApplicationCommandSubGroupData,
+    AutocompleteInteraction,
+    Awaitable,
+    BaseApplicationCommandOptionsData,
+    ButtonInteraction,
+    MessageContextMenuCommandInteraction,
+    ModalSubmitInteraction,
+    UserContextMenuCommandInteraction,
+    ChannelSelectMenuInteraction,
+    MentionableSelectMenuInteraction,
+    RoleSelectMenuInteraction,
+    StringSelectMenuInteraction,
+} from 'discord.js';
+import type {
+    DiscordEventCommand,
+    ExternalEventCommand,
+    SernEventCommand,
+} from '../handler/structures/events';
+import { CommandType } from '../handler/structures/enums';
+import type { Args, SlashOptions } from './handler';
+import type Context from '../handler/structures/context';
+import type { AutocompletePlugin, CommandPlugin, EventPlugin } from '../handler/plugins/plugin';
+import { EventType } from '../handler/structures/enums';
+import type { UserSelectMenuInteraction } from 'discord.js';
+
+export interface Module {
+    type?: CommandType | EventType;
+    name?: string;
+    description?: string;
+    execute: (...args: any[]) => any;
+}
+
+export interface TextCommand extends Module {
+    type: CommandType.Text;
+    onEvent: EventPlugin<CommandType.Text>[];
+    plugins: CommandPlugin[];
+    alias?: string[];
+    execute: (ctx: Context, args: ['text', string[]]) => Awaitable<unknown>;
+}
+
+export interface SlashCommand extends Module {
+    type: CommandType.Slash;
+    onEvent: EventPlugin<CommandType.Slash>[];
+    plugins: CommandPlugin[];
+    options?: SernOptionsData[];
+    execute: (ctx: Context, args: ['slash', SlashOptions]) => Awaitable<unknown>;
+}
+
+export interface BothCommand extends Module {
+    type: CommandType.Both;
+    onEvent: EventPlugin<CommandType.Both>[];
+    plugins: CommandPlugin[];
+    alias?: string[];
+    options?: SernOptionsData[];
+    execute: (ctx: Context, args: Args) => Awaitable<unknown>;
+}
+
+export interface ContextMenuUser extends Module {
+    type: CommandType.CtxUser;
+    onEvent: EventPlugin<CommandType.CtxUser>[];
+    plugins: CommandPlugin[];
+    execute: (ctx: UserContextMenuCommandInteraction) => Awaitable<unknown>;
+}
+
+export interface ContextMenuMsg extends Module {
+    type: CommandType.CtxMsg;
+    onEvent: EventPlugin<CommandType.CtxMsg>[];
+    plugins: CommandPlugin[];
+    execute: (ctx: MessageContextMenuCommandInteraction) => Awaitable<unknown>;
+}
+
+export interface ButtonCommand extends Module {
+    type: CommandType.Button;
+    onEvent: EventPlugin<CommandType.Button>[];
+    plugins: CommandPlugin[];
+    execute: (ctx: ButtonInteraction) => Awaitable<unknown>;
+}
+
+export interface StringSelectCommand extends Module {
+    type: CommandType.StringSelect;
+    onEvent: EventPlugin<CommandType.StringSelect>[];
+    plugins: CommandPlugin[];
+    execute: (ctx: StringSelectMenuInteraction) => Awaitable<unknown>;
+}
+
+export interface ChannelSelectCommand extends Module {
+    type: CommandType.ChannelSelect;
+    onEvent: EventPlugin<CommandType.ChannelSelect>[];
+    plugins: CommandPlugin[];
+    execute: (ctx: ChannelSelectMenuInteraction) => Awaitable<unknown>;
+}
+
+export interface RoleSelectCommand extends Module {
+    type: CommandType.RoleSelect;
+    onEvent: EventPlugin<CommandType.RoleSelect>[];
+    plugins: CommandPlugin[];
+    execute: (ctx: RoleSelectMenuInteraction) => Awaitable<unknown>;
+}
+
+export interface MentionableSelectCommand extends Module {
+    type: CommandType.MentionableSelect;
+    onEvent: EventPlugin<CommandType.MentionableSelect>[];
+    plugins: CommandPlugin[];
+    execute: (ctx: MentionableSelectMenuInteraction) => Awaitable<unknown>;
+}
+
+export interface UserSelectCommand extends Module {
+    type: CommandType.UserSelect;
+    onEvent: EventPlugin<CommandType.UserSelect>[];
+    plugins: CommandPlugin[];
+    execute: (ctx: UserSelectMenuInteraction) => Awaitable<unknown>;
+}
+
+export interface ModalSubmitCommand extends Module {
+    type: CommandType.Modal;
+    onEvent: EventPlugin<CommandType.Modal>[];
+    plugins: CommandPlugin[];
+    execute: (ctx: ModalSubmitInteraction) => Awaitable<unknown>;
+}
+
+export interface AutocompleteCommand extends Module {
+    name?: never;
+    description?: never;
+    type?: never;
+    onEvent: AutocompletePlugin[];
+    execute: (ctx: AutocompleteInteraction) => Awaitable<unknown>;
+}
+
+export type EventModule = DiscordEventCommand | SernEventCommand | ExternalEventCommand;
+export type CommandModule =
+    | TextCommand
+    | SlashCommand
+    | BothCommand
+    | ContextMenuUser
+    | ContextMenuMsg
+    | ButtonCommand
+    | StringSelectCommand
+    | MentionableSelectCommand
+    | UserSelectCommand
+    | ChannelSelectCommand
+    | RoleSelectCommand
+    | ModalSubmitCommand;
+
+export type AnyModule = CommandModule | EventModule;
+
+//https://stackoverflow.com/questions/64092736/alternative-to-switch-statement-for-typescript-discriminated-union
+// Explicit Module Definitions for mapping
+export type CommandModuleDefs = {
+    [CommandType.Text]: TextCommand;
+    [CommandType.Slash]: SlashCommand;
+    [CommandType.Both]: BothCommand;
+    [CommandType.CtxMsg]: ContextMenuMsg;
+    [CommandType.CtxUser]: ContextMenuUser;
+    [CommandType.Button]: ButtonCommand;
+    [CommandType.StringSelect]: StringSelectCommand;
+    [CommandType.RoleSelect]: RoleSelectCommand;
+    [CommandType.ChannelSelect]: ChannelSelectCommand;
+    [CommandType.MentionableSelect]: MentionableSelectCommand;
+    [CommandType.UserSelect]: UserSelectCommand;
+    [CommandType.Modal]: ModalSubmitCommand;
+};
+
+export type EventModuleDefs = {
+    [EventType.Sern]: SernEventCommand;
+    [EventType.Discord]: DiscordEventCommand;
+    [EventType.External]: ExternalEventCommand;
+};
+
+export interface SernAutocompleteData
+    extends Omit<BaseApplicationCommandOptionsData, 'autocomplete'> {
+    autocomplete: true;
+    type:
+        | ApplicationCommandOptionType.String
+        | ApplicationCommandOptionType.Number
+        | ApplicationCommandOptionType.Integer;
+    command: AutocompleteCommand;
+}
+
+/**
+ * Type that replaces autocomplete with {@link SernAutocompleteData}
+ */
+export type BaseOptions =
+    | ApplicationCommandChoicesData
+    | ApplicationCommandNonOptionsData
+    | ApplicationCommandChannelOptionData
+    | ApplicationCommandNumericOptionData
+    | ApplicationCommandAttachmentOption
+    | SernAutocompleteData;
+
+export interface SernSubCommandData extends BaseApplicationCommandOptionsData {
+    type: ApplicationCommandOptionType.Subcommand;
+    required?: never;
+    options?: BaseOptions[];
+}
+
+export interface SernSubCommandGroupData extends BaseApplicationCommandOptionsData {
+    type: ApplicationCommandOptionType.SubcommandGroup;
+    required?: never;
+    options?: SernSubCommandData[];
+}
+
+export type SernOptionsData<U extends ApplicationCommandOptionData = ApplicationCommandOptionData> =
+    U extends ApplicationCommandSubCommandData
+        ? SernSubCommandData
+        : U extends ApplicationCommandSubGroupData
+        ? SernSubCommandGroupData
+        : BaseOptions;

test/cjs/tsconfig.json

@@ -0,0 +1,20 @@
+{
+    "compilerOptions": {
+        "target": "esnext",
+        "module": "commonjs",
+        "outDir": "dist",
+        "rootDir": "src",
+        "strict": true,
+        "esModuleInterop": true,
+        "noImplicitAny": true,
+        "strictNullChecks": true,
+        "importsNotUsedAsValues": "error",
+        "baseUrl": ".",
+        "resolveJsonModule": true,
+        "moduleResolution": "node",
+        "skipLibCheck": true,
+        "allowSyntheticDefaultImports": true,
+        "forceConsistentCasingInFileNames": true
+    },
+    "include": ["src/secrets.json", "src"]
+}

test/esm/tsconfig.json

@@ -0,0 +1,20 @@
+{
+    "compilerOptions": {
+        "target": "esnext",
+        "module": "esnext",
+        "outDir": "dist",
+        "rootDir": "src",
+        "strict": true,
+        "esModuleInterop": true,
+        "noImplicitAny": true,
+        "strictNullChecks": true,
+        "importsNotUsedAsValues": "error",
+        "baseUrl": ".",
+        "resolveJsonModule": true,
+        "moduleResolution": "node",
+        "skipLibCheck": true,
+        "allowSyntheticDefaultImports": true,
+        "forceConsistentCasingInFileNames": true
+    },
+    "include": ["src/secrets.json", "src"]
+}

tsconfig-base.json

@@ -1,17 +1,18 @@
 {
-  "compilerOptions": {
-    "rootDir": "src",
-    "strict": true,
-    "esModuleInterop": true,
-    "noImplicitAny": true,
-    "strictNullChecks": true,
-    "importsNotUsedAsValues": "error",
-    "moduleResolution": "node",
-    "skipLibCheck": true,
-    "declaration": true,
-    "allowSyntheticDefaultImports": true,
-    "forceConsistentCasingInFileNames": true,
-  },
-  "exclude": ["node_modules", "dist"],
-  "include": ["src"],
+    "compilerOptions": {
+        "rootDir": "src",
+        "strict": true,
+        "esModuleInterop": true,
+        "noImplicitAny": true,
+        "experimentalDecorators": true,
+        "strictNullChecks": true,
+        "importsNotUsedAsValues": "error",
+        "moduleResolution": "node",
+        "skipLibCheck": true,
+        "declaration": true,
+        "allowSyntheticDefaultImports": true,
+        "forceConsistentCasingInFileNames": true
+    },
+    "exclude": ["node_modules", "dist"],
+    "include": ["src"]
 }

tsconfig-cjs.json

@@ -1,8 +1,8 @@
 {
-  "extends": "./tsconfig-base.json",
-  "compilerOptions": {
-    "module": "commonjs",
-    "outDir": "dist/cjs",
-    "target": "esnext"
-  }
-}
+    "extends": "./tsconfig-base.json",
+    "compilerOptions": {
+        "module": "commonjs",
+        "outDir": "dist/cjs",
+        "target": "esnext"
+    }
+}

tsconfig-esm.json

@@ -1,8 +1,8 @@
 {
-  "extends": "./tsconfig-base.json",
-  "compilerOptions": {
-    "module": "esnext",
-    "outDir": "dist/esm",
-    "target": "esnext"
-  }
-}
+    "extends": "./tsconfig-base.json",
+    "compilerOptions": {
+        "module": "esnext",
+        "outDir": "dist/esm",
+        "target": "esnext"
+    }
+}

tsup.config.js

@@ -1,38 +1,38 @@
 import { defineConfig } from 'tsup';
-
+const shared = {
+    entry: ['src/index.ts'],
+    external: ['discord.js'],
+    platform: 'node',
+    clean: true,
+    sourcemap: false,
+};
 export default defineConfig([
     {
-        entry: ['src/index.ts'],
-        format : 'esm',
-        sourcemap: false,
+        format: 'esm',
         target: 'node16',
-        tsconfig : './tsconfig-esm.json',
-        outDir : './dist/esm',
-        platform: 'node',
+        tsconfig: './tsconfig-esm.json',
+        outDir: './dist/esm',
         external: ['discord.js'],
-        clean: true,
         treeshake: true,
         outExtension() {
             return {
-                js : '.mjs'
+                js: '.mjs',
             };
-        }
+        },
+        ...shared,
     },
     {
-        entry: ['src/index.ts'],
-        format : 'cjs',
+        format: 'cjs',
         splitting: false,
-        sourcemap: false,
         external: ['discord.js'],
-        clean: true,
         target: 'node16',
-        tsconfig : './tsconfig-cjs.json',
-        outDir : './dist/cjs',
-        platform: 'node',
+        tsconfig: './tsconfig-cjs.json',
+        outDir: './dist/cjs',
         outExtension() {
             return {
-                js : '.cjs'
+                js: '.cjs',
             };
-        }
-    }
+        },
+        ...shared,
+    },
 ]);