@pikokr/command.ts 3.0.0-dev.7170769 → 3.0.0-dev.85a29c3

package/dist/error/PermissionRequired.d.ts

@@ -0,0 +1,10 @@
+import { GuildMember, Permissions } from 'discord.js';
+export declare class UserPermissionRequired extends Error {
+    user: GuildMember;
+    permissions: Permissions;
+    constructor(user: GuildMember, permissions: Permissions);
+}
+export declare class ClientPermissionRequired extends Error {
+    permissions: Permissions;
+    constructor(permissions: Permissions);
+}

package/dist/error/PermissionRequired.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClientPermissionRequired = exports.UserPermissionRequired = void 0;
+class UserPermissionRequired extends Error {
+    constructor(user, permissions) {
+        super();
+        this.user = user;
+        this.permissions = permissions;
+    }
+}
+exports.UserPermissionRequired = UserPermissionRequired;
+class ClientPermissionRequired extends Error {
+    constructor(permissions) {
+        super();
+        this.permissions = permissions;
+    }
+}
+exports.ClientPermissionRequired = ClientPermissionRequired;

package/dist/error/index.d.ts

@@ -1,2 +1,6 @@
 export * from './InvalidTargetError';
 export * from './ModuleError';
+export * from './ArgumentNotProvided';
+export * from './ArgumentConverterNotFound';
+export * from './CommandCheckFailed';
+export * from './PermissionRequired';

package/dist/error/index.js

@@ -12,3 +12,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./InvalidTargetError"), exports);
 __exportStar(require("./ModuleError"), exports);
+__exportStar(require("./ArgumentNotProvided"), exports);
+__exportStar(require("./ArgumentConverterNotFound"), exports);
+__exportStar(require("./CommandCheckFailed"), exports);
+__exportStar(require("./PermissionRequired"), exports);

package/dist/index.d.ts

@@ -1,5 +1,8 @@
 import 'reflect-metadata';
+import './typings';
 export * from './interface';
 export * from './structures';
 export * from './error';
 export * from './command';
+export * from './listener';
+export * from './builtinModules/BuiltInModule';

package/dist/index.js

@@ -11,7 +11,10 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 require("reflect-metadata");
+require("./typings");
 __exportStar(require("./interface"), exports);
 __exportStar(require("./structures"), exports);
 __exportStar(require("./error"), exports);
 __exportStar(require("./command"), exports);
+__exportStar(require("./listener"), exports);
+__exportStar(require("./builtinModules/BuiltInModule"), exports);

package/dist/listener/Listener.d.ts

@@ -0,0 +1,5 @@
+export declare class Listener {
+    name: string;
+    execute: Function;
+    constructor(name: string, execute: Function);
+}

package/dist/listener/Listener.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Listener = void 0;
+class Listener {
+    constructor(name, execute) {
+        this.name = name;
+        this.execute = execute;
+    }
+}
+exports.Listener = Listener;

package/dist/listener/decorator.d.ts

@@ -0,0 +1,2 @@
+import { Module } from '../structures';
+export declare const listener: (event: string) => (target: Module, propertyKey: string) => void;

package/dist/listener/decorator.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.listener = void 0;
+const utils_1 = require("../utils");
+const constants_1 = require("../constants");
+const Listener_1 = require("./Listener");
+const listener = (event) => {
+    return (target, propertyKey) => {
+        utils_1.checkTarget(target);
+        let properties = Reflect.getMetadata(constants_1.KListeners, target);
+        const listener = new Listener_1.Listener(event, Reflect.get(target, propertyKey));
+        if (properties) {
+            properties.push(listener);
+        }
+        else {
+            properties = [listener];
+            Reflect.defineMetadata(constants_1.KListeners, properties, target);
+        }
+    };
+};
+exports.listener = listener;

package/dist/listener/index.d.ts

@@ -0,0 +1,2 @@
+export * from './Listener';
+export * from './decorator';

package/dist/listener/index.js

@@ -0,0 +1,14 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./Listener"), exports);
+__exportStar(require("./decorator"), exports);

package/dist/structures/CommandClient.d.ts

@@ -16,7 +16,6 @@ export declare class CommandClient {
     owners: string[];
     registry: Registry;
     client: Client;
-    private handle;
     private _isReady;
     private fetchOwners;
     ready(): Promise<void>;

package/dist/structures/CommandClient.js

@@ -27,6 +27,7 @@ exports.CommandClient = void 0;
 const lodash_1 = __importDefault(require("lodash"));
 const Registry_1 = require("./Registry");
 const discord_js_1 = require("discord.js");
+const builtinModules_1 = require("../builtinModules");
 class CommandClient {
     constructor(_a) {
         var { client } = _a, options = __rest(_a, ["client"]);
@@ -40,54 +41,30 @@ class CommandClient {
             },
             owners: 'auto',
         });
-        this.client.on('messageCreate', (msg) => this.handle(msg));
-        this.client.once('ready', this.ready);
+        this.client.once('ready', () => this.ready());
+        this.registry.registerModule(new builtinModules_1.CommandHandler(this.registry));
+        this.registry.registerModule(new builtinModules_1.BuiltinCommandConverters(this));
     }
-    handle(msg) {
+    fetchOwners() {
+        var _a, _b;
         return __awaiter(this, void 0, void 0, function* () {
-            const prefixList = typeof this.options.command.prefix === 'string'
-                ? this.options.command.prefix
-                : typeof this.options.command.prefix === 'function'
-                    ? yield this.options.command.prefix(msg)
-                    : this.options.command.prefix;
-            let prefix;
-            if (typeof prefixList === 'object') {
-                const res = prefixList.find((x) => msg.content.includes(x));
-                if (!res)
-                    return;
-                prefix = res;
-            }
-            else {
-                if (!msg.content.includes(prefixList))
-                    return;
-                prefix = prefixList;
-            }
-            const args = msg.content.slice(prefix.length).split(' ');
-            const command = args.shift();
-            if (!command)
-                return;
-            this.registry.commands;
-            console.log(command);
-            console.log(args);
+            yield ((_a = this.client.application) === null || _a === void 0 ? void 0 : _a.fetch());
+            const o = (_b = this.client.application) === null || _b === void 0 ? void 0 : _b.owner;
+            if (!o)
+                return [];
+            if (o instanceof discord_js_1.User)
+                return [o.id];
+            else
+                return o.members.map((x) => x.id);
         });
     }
-    fetchOwners() {
-        var _a;
-        const o = (_a = this.client.application) === null || _a === void 0 ? void 0 : _a.owner;
-        if (!o)
-            return [];
-        if (o instanceof discord_js_1.User)
-            return [o.id];
-        else
-            return o.members.map((x) => x.id);
-    }
     ready() {
         return __awaiter(this, void 0, void 0, function* () {
             if (this._isReady)
                 return;
             this._isReady = true;
             if (this.options.owners === 'auto') {
-                const owners = this.fetchOwners();
+                const owners = yield this.fetchOwners();
                 this.owners.push(...owners);
             }
         });

package/dist/structures/Module.d.ts

@@ -1,4 +1,11 @@
+import type { Command } from '../command';
+import { Listener } from '../listener';
+import { ArgumentConverter } from '../command';
 export declare abstract class Module {
+    get commands(): Command[];
+    get listeners(): Listener[];
+    get argumentConverters(): ArgumentConverter[];
+    get path(): string | undefined;
     load(): void;
     unload(): void;
     beforeReload(): void;

package/dist/structures/Module.js

@@ -1,7 +1,20 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Module = void 0;
+const constants_1 = require("../constants");
 class Module {
+    get commands() {
+        return Reflect.getMetadata(constants_1.KCommands, this) || [];
+    }
+    get listeners() {
+        return Reflect.getMetadata(constants_1.KListeners, this) || [];
+    }
+    get argumentConverters() {
+        return Reflect.getMetadata(constants_1.KArgumentConverters, this) || [];
+    }
+    get path() {
+        return Reflect.getMetadata(constants_1.KModulePath, this);
+    }
     load() { }
     unload() { }
     beforeReload() { }

package/dist/structures/Registry.d.ts

@@ -1,13 +1,23 @@
 import { CommandClient } from './CommandClient';
 import { Module } from './Module';
 import { Command } from '../command';
+import { Collection } from 'discord.js';
+import { ArgumentConverter } from '../command';
 export declare class Registry {
-    private client;
+    client: CommandClient;
     constructor(client: CommandClient);
-    modules: Module[];
+    modules: Collection<symbol, Module>;
     get commands(): Command[];
-    registerModule(module: Module): void;
-    loadModule(file: string, absolute?: boolean): void;
-    unregisterModule(module: Module): void;
-    unloadModule(module: Module): void;
+    get argumentConverters(): ArgumentConverter[];
+    registerModule(module: Module): Module;
+    loadModulesIn(dir: string, absolute?: boolean): Promise<void>;
+    loadModule(file: string, absolute?: boolean): Promise<Module>;
+    unregisterModule(module: Module): Promise<Module>;
+    unloadModule(module: Module): Promise<void>;
+    reloadModule(module: Module): Promise<boolean>;
+    reloadAll(): Promise<{
+        path: string;
+        success: boolean;
+        error?: Error | undefined;
+    }[]>;
 }

package/dist/structures/Registry.js

@@ -1,4 +1,13 @@
 "use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -8,44 +17,126 @@ const Module_1 = require("./Module");
 const constants_1 = require("../constants");
 const path_1 = __importDefault(require("path"));
 const error_1 = require("../error");
+const discord_js_1 = require("discord.js");
+const walk_sync_1 = __importDefault(require("walk-sync"));
 class Registry {
     constructor(client) {
         this.client = client;
-        this.modules = [];
+        this.modules = new discord_js_1.Collection();
     }
     get commands() {
         const result = [];
-        for (const module of this.modules) {
-            const commands = Reflect.getMetadata(constants_1.KCommands, module);
-            result.push(...commands);
+        for (const [, module] of this.modules) {
+            result.push(...module.commands);
+        }
+        return result;
+    }
+    get argumentConverters() {
+        const result = [];
+        for (const [, module] of this.modules) {
+            result.push(...module.argumentConverters);
         }
         return result;
     }
     registerModule(module) {
-        // TODO
+        this.modules.set(Symbol(module.constructor.name), module);
+        const list = [];
+        for (const listener of module.listeners) {
+            const bound = listener.execute.bind(module);
+            list.push({ event: listener.name, execute: bound });
+            this.client.client.on(listener.name, bound);
+        }
+        Reflect.defineMetadata(constants_1.KListenerExecuteCache, list, module);
+        return module;
+    }
+    loadModulesIn(dir, absolute = false) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let p = absolute ? dir : path_1.default.join(require.main.path, dir);
+            for (const i of walk_sync_1.default(p)) {
+                yield this.loadModule(path_1.default.join(p, i), true);
+            }
+        });
     }
     loadModule(file, absolute = false) {
-        let p = absolute ? file : path_1.default.join(require.main.path, file);
-        let m;
-        try {
-            m = require(p);
-        }
-        catch (e) {
-            throw new error_1.ModuleLoadError(p);
-        }
-        if (!m.install)
-            throw new error_1.InvalidModuleError('Install function not found.');
-        const mod = m.install();
-        if (!(mod instanceof Module_1.Module))
-            throw new error_1.InvalidTargetError();
-        Reflect.defineMetadata(constants_1.KModulePath, require.resolve(p), mod);
-        this.registerModule(m);
+        return __awaiter(this, void 0, void 0, function* () {
+            let p = absolute ? file : path_1.default.join(require.main.path, file);
+            let m;
+            try {
+                m = require(p);
+            }
+            catch (e) {
+                throw new error_1.ModuleLoadError(p);
+            }
+            if (m.loaded)
+                throw new Error('MODULE_ALREADY_LOADED');
+            if (!m.install)
+                throw new error_1.InvalidModuleError('Install function not found.');
+            const mod = m.install(this.client);
+            if (!(mod instanceof Module_1.Module))
+                throw new error_1.InvalidTargetError();
+            Reflect.defineMetadata(constants_1.KModulePath, require.resolve(p), mod);
+            this.registerModule(mod);
+            yield mod.load();
+            m.loaded = true;
+            return mod;
+        });
     }
     unregisterModule(module) {
-        // TODO
+        return __awaiter(this, void 0, void 0, function* () {
+            if (Reflect.getMetadata(constants_1.KBuiltInModule, module))
+                throw new Error('Built-in modules cannot be unloaded');
+            const symbol = this.modules.findKey((x) => x === module);
+            if (!symbol)
+                return module;
+            yield module.unload();
+            const list = Reflect.getMetadata(constants_1.KListenerExecuteCache, module);
+            for (const listener of list) {
+                this.client.client.removeListener(listener.event, listener.execute);
+            }
+            this.modules.delete(symbol);
+            return module;
+        });
     }
     unloadModule(module) {
-        // TODO
+        return __awaiter(this, void 0, void 0, function* () {
+            const p = Reflect.getMetadata(constants_1.KModulePath, module);
+            if (!p)
+                throw new error_1.InvalidModuleError('This module is not loaded by loadModule.');
+            yield this.unregisterModule(module);
+            delete require.cache[p];
+        });
+    }
+    reloadModule(module) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield module.beforeReload();
+            const p = Reflect.getMetadata(constants_1.KModulePath, module);
+            yield this.unloadModule(module);
+            const mod = yield this.loadModule(p, true);
+            yield mod.afterReload();
+            return true;
+        });
+    }
+    reloadAll() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const results = [];
+            for (const [, module] of this.modules.filter((x) => !!x.path)) {
+                try {
+                    yield this.reloadModule(module);
+                    results.push({
+                        path: module.path,
+                        success: false,
+                    });
+                }
+                catch (e) {
+                    results.push({
+                        error: e,
+                        path: module.path,
+                        success: false,
+                    });
+                }
+            }
+            return results;
+        });
     }
 }
 exports.Registry = Registry;

package/dist/structures/index.d.ts

@@ -1,2 +1,3 @@
-export * from './CommandClient';
 export * from './Module';
+export * from './CommandClient';
+export * from './Registry';

package/dist/structures/index.js

@@ -10,5 +10,6 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./CommandClient"), exports);
 __exportStar(require("./Module"), exports);
+__exportStar(require("./CommandClient"), exports);
+__exportStar(require("./Registry"), exports);

package/dist/typings.d.ts

@@ -0,0 +1,11 @@
+import type { Command } from './command';
+import { CommandClient } from './structures';
+declare module 'discord.js' {
+    interface Message {
+        data: {
+            command: Command;
+            prefix: string;
+            cts: CommandClient;
+        };
+    }
+}

package/dist/typings.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/utils.d.ts

@@ -0,0 +1 @@
+export declare const checkTarget: (target: Object) => void;

package/dist/utils.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkTarget = void 0;
+const structures_1 = require("./structures");
+const error_1 = require("./error");
+const checkTarget = (target) => {
+    if (!(target instanceof structures_1.Module))
+        throw new error_1.InvalidTargetError();
+};
+exports.checkTarget = checkTarget;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@pikokr/command.ts",
   "description": "Discord.js command framework for typescript.",
-  "version": "3.0.0-dev.7170769",
+  "version": "3.0.0-dev.85a29c3",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "license": "MIT",
@@ -16,7 +16,8 @@
     "@types/node": "^14.14.37",
     "lodash": "^4.17.21",
     "reflect-metadata": "^0.1.13",
-    "typescript": "^4.2.3"
+    "typescript": "^4.2.3",
+    "walk-sync": "^3.0.0"
   },
   "repository": {
     "type": "git",

package/src/builtinModules/BuiltInModule.ts

@@ -0,0 +1,9 @@
+import { Module } from '../structures'
+import { KBuiltInModule } from '../constants'
+
+export class BuiltInModule extends Module {
+  constructor() {
+    super()
+    Reflect.defineMetadata(KBuiltInModule, true, this)
+  }
+}

package/src/builtinModules/BuiltinCommandConverters.ts

@@ -0,0 +1,56 @@
+import { BuiltInModule } from './BuiltInModule'
+import { argumentConverter } from '../command'
+import { Client, GuildMember, Message, User } from 'discord.js'
+import { CommandClient } from '../structures'
+
+export class BuiltinCommandConverters extends BuiltInModule {
+  client: Client
+
+  constructor(private cts: CommandClient) {
+    super()
+    this.client = cts.client
+  }
+
+  @argumentConverter(Message, false)
+  message(msg: Message) {
+    return msg
+  }
+
+  @argumentConverter(String)
+  string(msg: Message, arg: string) {
+    return arg
+  }
+
+  getUserIDByMention(mention: string): `${bigint}` | undefined {
+    if (!mention) return
+    if (mention.startsWith('<@') && mention.endsWith('>')) {
+      mention = mention.slice(2, -1)
+      if (mention.startsWith('!')) {
+        mention = mention.slice(1)
+      }
+      return mention as `${bigint}`
+    }
+  }
+
+  @argumentConverter(User)
+  user(value: string): User | null {
+    const id = this.getUserIDByMention(value)
+    if (!id) return null
+    const user = this.client.users.cache.get(id)
+    return user || null
+  }
+
+  @argumentConverter(GuildMember)
+  member(value: string, msg: Message): GuildMember | undefined {
+    const id = this.getUserIDByMention(value)
+    if (!id) return
+    const user = msg.guild?.members.cache.get(id)
+    return user || undefined
+  }
+
+  @argumentConverter(Number)
+  number(value: string) {
+    const n = Number(value)
+    return isNaN(n) ? undefined : n
+  }
+}