reciple 1.5.3 → 1.6.0

package/bin/bin.js

@@ -12,7 +12,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 var _a, _b;
 Object.defineProperty(exports, "__esModule", { value: true });
 const Config_1 = require("./reciple/classes/Config");
-const Client_1 = require("./reciple/classes/Client");
+const RecipleClient_1 = require("./reciple/classes/RecipleClient");
 const fs_1 = require("fs");
 const version_1 = require("./reciple/version");
 const flags_1 = require("./reciple/flags");
@@ -29,7 +29,7 @@ if ((0, fs_1.readdirSync)('./').filter(f => !f.startsWith('.') && allowedFiles.i
         process.exit(0);
 }
 const config = new Config_1.RecipleConfig((_b = flags_1.flags.config) !== null && _b !== void 0 ? _b : './reciple.yml').parseConfig().getConfig();
-const client = new Client_1.RecipleClient(Object.assign({ config: config }, config.client));
+const client = new RecipleClient_1.RecipleClient(Object.assign({ config: config }, config.client));
 (() => __awaiter(void 0, void 0, void 0, function* () {
     yield client.startModules();
     client.on('ready', () => __awaiter(void 0, void 0, void 0, function* () {

package/bin/index.d.ts

@@ -1,10 +1,11 @@
 import discord from 'discord.js';
 export declare const discordjs: typeof discord;
-export * from './reciple/classes/Client';
+export * from './reciple/classes/RecipleClient';
 export * from './reciple/classes/Config';
 export * from './reciple/classes/builders/InteractionCommandBuilder';
 export * from './reciple/classes/builders/MessageCommandBuilder';
 export * from './reciple/classes/builders/MessageCommandOptionBuilder';
+export * from './reciple/classes/builders/MessageCommandOptions';
 export * from './reciple/hasPermissions';
 export * from './reciple/flags';
 export * from './reciple/isIgnoredChannel';

package/bin/index.js

@@ -20,11 +20,12 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.discordjs = void 0;
 const discord_js_1 = __importDefault(require("discord.js"));
 exports.discordjs = discord_js_1.default;
-__exportStar(require("./reciple/classes/Client"), exports);
+__exportStar(require("./reciple/classes/RecipleClient"), exports);
 __exportStar(require("./reciple/classes/Config"), exports);
 __exportStar(require("./reciple/classes/builders/InteractionCommandBuilder"), exports);
 __exportStar(require("./reciple/classes/builders/MessageCommandBuilder"), exports);
 __exportStar(require("./reciple/classes/builders/MessageCommandOptionBuilder"), exports);
+__exportStar(require("./reciple/classes/builders/MessageCommandOptions"), exports);
 __exportStar(require("./reciple/hasPermissions"), exports);
 __exportStar(require("./reciple/flags"), exports);
 __exportStar(require("./reciple/isIgnoredChannel"), exports);

package/bin/reciple/classes/{Client.d.ts → RecipleClient.d.ts}

@@ -3,8 +3,8 @@ import { interactionCommandBuilders } from '../registerInteractionCommands';
 import { MessageCommandBuilder, RecipleMessageCommandExecute } from './builders/MessageCommandBuilder';
 import { Logger as ILogger } from 'fallout-utility';
 import { Config } from './Config';
-import { ApplicationCommandDataResolvable, Awaitable, Client, ClientEvents, ClientOptions, Interaction, Message } from 'discord.js';
-import { recipleCommandBuilders, RecipleScript } from '../modules';
+import { ApplicationCommandDataResolvable, Awaitable, Client, ClientEvents, ClientOptions, CommandInteraction, Interaction, Message } from 'discord.js';
+import { recipleCommandBuilders, RecipleModule, RecipleScript } from '../modules';
 export interface RecipleClientOptions extends ClientOptions {
     config: Config;
 }
@@ -20,7 +20,7 @@ export interface RecipleClientEvents extends ClientEvents {
     recipleMessageCommandCreate: [command: RecipleMessageCommandExecute];
     recipleInteractionCommandCreate: [command: RecipleInteractionCommandExecute];
 }
-export interface RecipleClient extends Client {
+export interface RecipleClient<Ready extends boolean = boolean> extends Client<Ready> {
     on<E extends keyof RecipleClientEvents>(event: E, listener: (...args: RecipleClientEvents[E]) => Awaitable<void>): this;
     on<E extends string | symbol>(event: Exclude<E, keyof RecipleClientEvents>, listener: (...args: any) => Awaitable<void>): this;
     once<E extends keyof RecipleClientEvents>(event: E, listener: (...args: RecipleClientEvents[E]) => Awaitable<void>): this;
@@ -31,22 +31,23 @@ export interface RecipleClient extends Client {
     off<E extends string | symbol>(event: Exclude<E, keyof RecipleClientEvents>, listener: (...args: any) => Awaitable<void>): this;
     removeAllListeners<E extends keyof RecipleClientEvents>(event?: E): this;
     removeAllListeners(event?: string | symbol): this;
+    isReady(): this is RecipleClient<true>;
 }
-export declare class RecipleClient extends Client {
+export declare class RecipleClient<Ready extends boolean = boolean> extends Client<Ready> {
     config: Config;
     commands: RecipleClientCommands;
     otherApplicationCommandData: (interactionCommandBuilders | ApplicationCommandDataResolvable)[];
-    modules: RecipleScript[];
+    modules: RecipleModule[];
     logger: ILogger;
     version: string;
     constructor(options: RecipleClientOptions);
-    startModules(): Promise<RecipleClient>;
-    loadModules(): Promise<RecipleClient>;
+    startModules(): Promise<RecipleClient<Ready>>;
+    loadModules(): Promise<RecipleClient<Ready>>;
     addModule(script: RecipleScript, registerCommands?: boolean): Promise<void>;
-    addCommand(command: recipleCommandBuilders): RecipleClient;
-    addCommandListeners(): RecipleClient;
-    messageCommandExecute(message: Message): Promise<void>;
-    interactionCommandExecute(interaction: Interaction): Promise<void>;
-    getMessage<T = any>(messageKey: string, defaultMessage?: T): T;
+    addCommand(command: recipleCommandBuilders): RecipleClient<Ready>;
+    addCommandListeners(): RecipleClient<Ready>;
+    messageCommandExecute(message: Message, prefix?: string): Promise<void | RecipleMessageCommandExecute>;
+    interactionCommandExecute(interaction: Interaction | CommandInteraction): Promise<void | RecipleInteractionCommandExecute>;
+    getMessage<T = unknown>(messageKey: string, defaultMessage?: T): T;
     private _commandExecuteError;
 }

package/bin/reciple/classes/{Client.js → RecipleClient.js}

@@ -24,6 +24,7 @@ const version_1 = require("../version");
 const logger_1 = require("../logger");
 const discord_js_1 = require("discord.js");
 const modules_1 = require("../modules");
+const MessageCommandOptions_1 = require("./builders/MessageCommandOptions");
 class RecipleClient extends discord_js_1.Client {
     constructor(options) {
         super(options);
@@ -45,24 +46,22 @@ class RecipleClient extends discord_js_1.Client {
             const modules = yield (0, modules_1.loadModules)(this);
             if (!modules)
                 throw new Error('Failed to load modules.');
-            this.modules = modules.modules.map(m => m.script);
-            for (const command of modules.commands) {
-                if (!command.name)
-                    continue;
-                this.addCommand(command);
-            }
-            this.logger.info(`${Object.keys(this.commands.MESSAGE_COMMANDS).length} message commands loaded.`);
-            this.logger.info(`${Object.keys(this.commands.INTERACTION_COMMANDS).length} interaction commands loaded.`);
+            this.modules = modules.modules;
             return this;
         });
     }
     loadModules() {
         return __awaiter(this, void 0, void 0, function* () {
-            for (const module_ of this.modules) {
+            for (const module_ of this.modules.map(m => m.script)) {
                 if (typeof (module_ === null || module_ === void 0 ? void 0 : module_.onLoad) === 'function')
                     yield Promise.resolve(module_.onLoad(this));
             }
             this.logger.info(`${this.modules.length} modules loaded.`);
+            for (const command of this.modules.map(m => { var _a; return (_a = m.script.commands) !== null && _a !== void 0 ? _a : []; })[0]) {
+                this.addCommand(command);
+            }
+            this.logger.info(`${Object.keys(this.commands.MESSAGE_COMMANDS).length} message commands loaded.`);
+            this.logger.info(`${Object.keys(this.commands.INTERACTION_COMMANDS).length} interaction commands loaded.`);
             if (!this.config.commands.interactionCommand.registerCommands)
                 return this;
             yield (0, registerInteractionCommands_1.registerInteractionCommands)(this, [...Object.values(this.commands.INTERACTION_COMMANDS), ...this.otherApplicationCommandData]);
@@ -72,7 +71,14 @@ class RecipleClient extends discord_js_1.Client {
     addModule(script, registerCommands = true) {
         var _a;
         return __awaiter(this, void 0, void 0, function* () {
-            this.modules.push(script);
+            this.modules.push({
+                script,
+                info: {
+                    filename: undefined,
+                    versions: typeof script.versions == 'string' ? [script.versions] : script.versions,
+                    path: undefined
+                }
+            });
             if (typeof (script === null || script === void 0 ? void 0 : script.onLoad) === 'function')
                 yield Promise.resolve(script.onLoad(this));
             this.logger.info(`${this.modules.length} modules loaded.`);
@@ -106,12 +112,12 @@ class RecipleClient extends discord_js_1.Client {
             this.on('interactionCreate', (interaction) => { this.interactionCommandExecute(interaction); });
         return this;
     }
-    messageCommandExecute(message) {
+    messageCommandExecute(message, prefix) {
         var _a;
         return __awaiter(this, void 0, void 0, function* () {
-            if (!message.content || !this.config.commands.messageCommand.enabled)
+            if (!message.content || !this.isReady())
                 return;
-            const parseCommand = (0, fallout_utility_1.getCommand)(message.content, this.config.prefix || '!', this.config.commands.messageCommand.commandArgumentSeparator || ' ');
+            const parseCommand = (0, fallout_utility_1.getCommand)(message.content, prefix || this.config.prefix || '!', this.config.commands.messageCommand.commandArgumentSeparator || ' ');
             if (!(parseCommand === null || parseCommand === void 0 ? void 0 : parseCommand.command) || !parseCommand)
                 return;
             const command = this.commands.MESSAGE_COMMANDS[parseCommand.command.toLowerCase()];
@@ -126,38 +132,40 @@ class RecipleClient extends discord_js_1.Client {
                 const commandOptions = command.getCommandOptionValues(parseCommand);
                 if (command.validateOptions) {
                     if (commandOptions.some(o => o.invalid)) {
-                        yield message.reply(this.getMessage('invalidArguments', 'Invalid argument(s) given.')).catch(() => { });
+                        yield message.reply(this.getMessage('invalidArguments', 'Invalid argument(s) given.')).catch(err => this.logger.debug(err));
                         return;
                     }
                     if (commandOptions.some(o => o.missing)) {
-                        yield message.reply(this.getMessage('notEnoughArguments', 'Not enough arguments.')).catch(() => { });
+                        yield message.reply(this.getMessage('notEnoughArguments', 'Not enough arguments.')).catch(err => this.logger.debug(err));
                         return;
                     }
                 }
                 const options = {
                     message: message,
-                    options: commandOptions,
+                    options: new MessageCommandOptions_1.MessageCommandOptions(commandOptions),
                     command: parseCommand,
                     builder: command,
                     client: this
                 };
                 yield Promise.resolve(command.execute(options)).catch(err => this._commandExecuteError(err, options));
                 this.emit('recipleMessageCommandCreate', options);
+                return options;
             }
             else {
-                yield message.reply(this.getMessage('noPermissions', 'You do not have permission to use this command.')).catch((err) => this.logger.error(err));
+                yield message.reply(this.getMessage('noPermissions', 'You do not have permission to use this command.')).catch(err => this.logger.debug(err));
             }
         });
     }
     interactionCommandExecute(interaction) {
         var _a;
         return __awaiter(this, void 0, void 0, function* () {
-            if (!interaction || !interaction.isCommand() || !this.config.commands.interactionCommand.enabled)
+            if (!interaction || !interaction.isCommand() || !this.isReady())
                 return;
             const command = this.commands.INTERACTION_COMMANDS[interaction.commandName];
             if (!command)
                 return;
             if ((0, hasPermissions_1.hasPermissions)(command.name, (_a = interaction.memberPermissions) !== null && _a !== void 0 ? _a : undefined, this.config.permissions.interactionCommands, command)) {
+                // TODO: Deprecated allowEcuteInDM
                 if (!command.allowExecuteInDM && !interaction.inCachedGuild() || (0, isIgnoredChannel_1.isIgnoredChannel)(interaction.channelId, this.config.ignoredChannels))
                     return;
                 if (!command)
@@ -170,9 +178,10 @@ class RecipleClient extends discord_js_1.Client {
                 };
                 yield Promise.resolve(command.execute(options)).catch(err => this._commandExecuteError(err, options));
                 this.emit('recipleInteractionCommandCreate', options);
+                return options;
             }
             else {
-                yield interaction.reply(this.getMessage('noPermissions', 'You do not have permission to use this command.')).catch((err) => this.logger.error(err));
+                yield interaction.reply(this.getMessage('noPermissions', 'You do not have permission to use this command.')).catch(err => this.logger.debug(err));
             }
         });
     }
@@ -189,12 +198,12 @@ class RecipleClient extends discord_js_1.Client {
             if (command === null || command === void 0 ? void 0 : command.message) {
                 if (!this.config.commands.messageCommand.replyOnError)
                     return;
-                yield command.message.reply(this.getMessage('error', 'An error occurred.')).catch((e) => this.logger.error(e));
+                yield command.message.reply(this.getMessage('error', 'An error occurred.')).catch(err => this.logger.debug(err));
             }
             else if (command === null || command === void 0 ? void 0 : command.interaction) {
                 if (!this.config.commands.interactionCommand.replyOnError)
                     return;
-                yield command.interaction.followUp(this.getMessage('error', 'An error occurred.')).catch((e) => this.logger.error(e));
+                yield command.interaction.followUp(this.getMessage('error', 'An error occurred.')).catch(err => this.logger.debug(err));
             }
         });
     }

package/bin/reciple/classes/builders/InteractionCommandBuilder.d.ts

@@ -1,11 +1,11 @@
 import { CommandInteraction, PermissionFlags, PermissionString } from 'discord.js';
 import { SlashCommandBuilder } from '@discordjs/builders';
-import { RecipleClient } from '../Client';
+import { RecipleClient } from '../RecipleClient';
 export interface RecipleInteractionCommandExecute {
     interaction: CommandInteraction;
     command: InteractionCommandBuilder;
     builder: InteractionCommandBuilder;
-    client: RecipleClient;
+    client: RecipleClient<true>;
 }
 export declare class InteractionCommandBuilder extends SlashCommandBuilder {
     readonly builder = "INTERACTION_COMMAND";
@@ -13,6 +13,10 @@ export declare class InteractionCommandBuilder extends SlashCommandBuilder {
     allowExecuteInDM: boolean;
     execute: (options: RecipleInteractionCommandExecute) => void;
     setRequiredPermissions(requiredPermissions: (keyof PermissionFlags)[]): InteractionCommandBuilder;
+    /**
+     * TODO: Deprecated this
+     * @deprecated use `InteractionCommandBuilder.setDMPermission()` instead
+     */
     setAllowExecuteInDM(allowExecuteInDM: boolean): InteractionCommandBuilder;
     setExecute(execute: (options: RecipleInteractionCommandExecute) => void): InteractionCommandBuilder;
 }

package/bin/reciple/classes/builders/InteractionCommandBuilder.js

@@ -16,6 +16,10 @@ class InteractionCommandBuilder extends builders_1.SlashCommandBuilder {
         this.requiredPermissions = requiredPermissions;
         return this;
     }
+    /**
+     * TODO: Deprecated this
+     * @deprecated use `InteractionCommandBuilder.setDMPermission()` instead
+     */
     setAllowExecuteInDM(allowExecuteInDM) {
         if (typeof allowExecuteInDM !== 'boolean')
             throw new Error('allowExecuteInDM must be a boolean.');

package/bin/reciple/classes/builders/MessageCommandBuilder.d.ts

@@ -1,14 +1,15 @@
 import { MessageCommandOptionBuilder } from './MessageCommandOptionBuilder';
 import { Message, PermissionFlags, PermissionString } from 'discord.js';
 import { Command } from 'fallout-utility';
-import { RecipleClient } from '../Client';
+import { RecipleClient } from '../RecipleClient';
+import { MessageCommandOptions } from './MessageCommandOptions';
 export declare type CommandMessage = Command;
 export interface RecipleMessageCommandExecute {
     message: Message;
-    options: MessageCommandValidatedOption[];
+    options: MessageCommandOptions;
     command: CommandMessage;
     builder: MessageCommandBuilder;
-    client: RecipleClient;
+    client: RecipleClient<true>;
 }
 export interface MessageCommandValidatedOption {
     name: string;

package/bin/reciple/classes/builders/MessageCommandBuilder.js

@@ -72,7 +72,7 @@ class MessageCommandBuilder {
         const required = this.options.filter(o => o.required);
         const optional = this.options.filter(o => !o.required);
         const allOptions = [...required, ...optional];
-        let result = [];
+        const result = [];
         let i = 0;
         for (const option of allOptions) {
             const arg = args[i];

package/bin/reciple/classes/builders/MessageCommandOptions.d.ts

@@ -0,0 +1,8 @@
+import { MessageCommandValidatedOption } from './MessageCommandBuilder';
+export declare class MessageCommandOptions extends Array<MessageCommandValidatedOption> {
+    constructor(options: MessageCommandValidatedOption[]);
+    get(name: string, requied: true): MessageCommandValidatedOption;
+    get(name: string, requied?: boolean): MessageCommandValidatedOption | null;
+    getValue(name: string, requied: true): string;
+    getValue(name: string, requied?: boolean): string | null;
+}

package/bin/reciple/classes/builders/MessageCommandOptions.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MessageCommandOptions = void 0;
+class MessageCommandOptions extends Array {
+    constructor(options) {
+        super();
+        this.push(...options);
+    }
+    get(name, required) {
+        const option = this.find(o => o.name == name);
+        if (!(option === null || option === void 0 ? void 0 : option.value) == undefined && required)
+            throw new TypeError(`Can't find option named ${name}`);
+        return option !== null && option !== void 0 ? option : null;
+    }
+    getValue(name, requied) {
+        var _a;
+        const option = this.get(name, requied);
+        if (!(option === null || option === void 0 ? void 0 : option.value) && requied)
+            throw new TypeError(`Value of option named ${name} is undefined`);
+        return (_a = option === null || option === void 0 ? void 0 : option.value) !== null && _a !== void 0 ? _a : null;
+    }
+}
+exports.MessageCommandOptions = MessageCommandOptions;

package/bin/reciple/modules.d.ts

@@ -1,6 +1,6 @@
 import { InteractionCommandBuilder, RecipleInteractionCommandExecute } from './classes/builders/InteractionCommandBuilder';
 import { MessageCommandBuilder, RecipleMessageCommandExecute } from './classes/builders/MessageCommandBuilder';
-import { RecipleClient } from './classes/Client';
+import { RecipleClient } from './classes/RecipleClient';
 export declare type recipleCommandBuilders = MessageCommandBuilder | InteractionCommandBuilder;
 export declare type recipleCommandBuildersExecute = RecipleInteractionCommandExecute | RecipleMessageCommandExecute;
 export declare type loadedModules = {
@@ -16,9 +16,9 @@ export declare class RecipleScript {
 export interface RecipleModule {
     script: RecipleScript;
     info: {
-        filename: string;
+        filename?: string;
         versions: string[];
-        path: string;
+        path?: string;
     };
 }
 export declare function loadModules(client: RecipleClient): Promise<loadedModules>;

package/bin/reciple/modules.js

@@ -18,7 +18,7 @@ const version_1 = require("./version");
 const wildcard_match_1 = __importDefault(require("wildcard-match"));
 const path_1 = __importDefault(require("path"));
 function loadModules(client) {
-    var _a;
+    var _a, _b;
     return __awaiter(this, void 0, void 0, function* () {
         const response = { commands: [], modules: [] };
         const modulesDir = client.config.modulesFolder || './modules';
@@ -30,17 +30,17 @@ function loadModules(client) {
             return file.endsWith('.js') && (!file.startsWith('_') && !file.startsWith('.')) && !ignoredFiles.some(f => (0, wildcard_match_1.default)(f)(file));
         });
         for (const script of scripts) {
-            const modulePath = path_1.default.resolve(modulesDir, script);
+            const modulePath = path_1.default.join(process.cwd(), modulesDir, script);
             const commands = [];
             let module_;
             try {
                 const reqMod = require(modulePath);
-                module_ = !!(reqMod === null || reqMod === void 0 ? void 0 : reqMod.default) ? reqMod.default : reqMod;
+                module_ = typeof (reqMod === null || reqMod === void 0 ? void 0 : reqMod.default) != 'undefined' ? reqMod.default : reqMod;
                 if (!((_a = module_.versions) === null || _a === void 0 ? void 0 : _a.length))
                     throw new Error('Module does not have supported versions.');
                 const versions = typeof module_.versions === 'object' ? module_.versions : [module_.versions];
                 if (!versions.some(v => (0, version_1.isSupportedVersion)(v, version_1.version)))
-                    throw new Error('Module versions is not defined or unsupported.');
+                    throw new Error((_b = 'Module versions is not defined or unsupported; supported versions: ' + module_.versions) !== null && _b !== void 0 ? _b : 'none' + '; current version: ' + version_1.version);
                 if (!(yield Promise.resolve(module_.onStart(client))))
                     throw new Error(script + ' onStart is not defined or returned false.');
                 if (module_.commands) {
@@ -55,13 +55,13 @@ function loadModules(client) {
                 logger.error(error);
                 continue;
             }
-            response.commands = response.commands.concat(commands.filter((c) => {
+            response.commands.push(...commands.filter((c) => {
                 if (!c.name) {
-                    logger.error(`A message command name is not defined in ${script}`);
+                    logger.error(`A ${c.builder} command name is not defined in ${script}`);
                     return false;
                 }
                 if (c.builder === 'MESSAGE_COMMAND' && c.options.length && c.options.some(o => !o.name)) {
-                    logger.error(`A message command option name is not defined in ${script}`);
+                    logger.error(`A ${c.builder} option name is not defined in ${script}`);
                     return false;
                 }
                 return true;

package/bin/reciple/registerInteractionCommands.d.ts

@@ -1,6 +1,6 @@
 import { InteractionCommandBuilder } from './classes/builders/InteractionCommandBuilder';
 import { ApplicationCommandDataResolvable } from 'discord.js';
-import { RecipleClient } from './classes/Client';
+import { RecipleClient } from './classes/RecipleClient';
 import { ContextMenuCommandBuilder, SlashCommandBuilder, SlashCommandSubcommandBuilder, SlashCommandOptionsOnlyBuilder, SlashCommandSubcommandGroupBuilder, SlashCommandSubcommandsOnlyBuilder } from '@discordjs/builders';
 export declare type interactionCommandBuilders = InteractionCommandBuilder | ContextMenuCommandBuilder | SlashCommandBuilder | SlashCommandSubcommandBuilder | SlashCommandOptionsOnlyBuilder | SlashCommandSubcommandGroupBuilder | SlashCommandSubcommandsOnlyBuilder;
 export declare function registerInteractionCommands(client: RecipleClient, cmds?: (interactionCommandBuilders | ApplicationCommandDataResolvable)[], overwriteGuilds?: string | string[]): Promise<void>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "reciple",
-  "version": "1.5.3",
+  "version": "1.6.0",
   "description": "A Discord.js bot",
   "author": "FalloutStudios",
   "license": "GPL-3.0",
@@ -8,6 +8,9 @@
   "bin": {
     "reciple": "bin/bin.js"
   },
+  "engines": {
+    "node": ">=16.9.0"
+  },
   "files": [
     "bin",
     "resource",
@@ -16,12 +19,11 @@
     "README.md"
   ],
   "scripts": {
-    "clean": "rimraf bin",
-    "compile": "yarn clean && npx tsc",
-    "build": "yarn compile && npm un reciple -g && npm i ./ -g",
-    "build:publish": "yarn run build && yarn run changelog && yarn publish",
-    "test": "cd test && npx reciple",
-    "test:build": "yarn run build && yarn test:run"
+    "clean": "rm -rf bin",
+    "build": "yarn clean && npx tsc && npm un reciple -g && npm i ./ -g",
+    "build:publish": "yarn run build && yarn publish",
+    "test": "yarn run build && yarn test:run",
+    "test:start": "cd test && npx reciple"
   },
   "dependencies": {
     "commander": "^9.3.0",