reciple 6.0.0-dev.3 → 6.0.0-dev.30

package/dist/cjs/reciple/classes/builders/MessageCommandBuilder.js

@@ -1,242 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.validateMessageCommandOptions = exports.MessageCommandBuilder = void 0;
-const builders_1 = require("../../types/builders");
-const discord_js_1 = require("discord.js");
-const MessageCommandOptionManager_1 = require("../managers/MessageCommandOptionManager");
-const MessageCommandOptionBuilder_1 = require("./MessageCommandOptionBuilder");
-/**
- * Reciple builder for message command
- */
-class MessageCommandBuilder {
-    constructor(data) {
-        this.type = builders_1.CommandBuilderType.MessageCommand;
-        this.name = '';
-        this.description = '';
-        this.cooldown = 0;
-        this.aliases = [];
-        this.validateOptions = false;
-        this.options = [];
-        this.requiredBotPermissions = [];
-        this.requiredMemberPermissions = [];
-        this.allowExecuteInDM = true;
-        this.allowExecuteByBots = false;
-        this.execute = () => {
-            /* Execute */
-        };
-        if (data?.name !== undefined)
-            this.setName(data.name);
-        if (data?.description !== undefined)
-            this.setDescription(data.description);
-        if (data?.aliases !== undefined)
-            this.addAliases(data.aliases);
-        if (data?.cooldown !== undefined)
-            this.setCooldown(Number(data?.cooldown));
-        if (data?.requiredBotPermissions !== undefined)
-            this.setRequiredBotPermissions(data.requiredBotPermissions);
-        if (data?.requiredMemberPermissions !== undefined)
-            this.setRequiredMemberPermissions(data.requiredMemberPermissions);
-        if (data?.halt !== undefined)
-            this.setHalt(data.halt);
-        if (data?.execute !== undefined)
-            this.setExecute(data.execute);
-        if (data?.metadata !== undefined)
-            this.setMetadata(data.metadata);
-        if (data?.allowExecuteByBots !== undefined)
-            this.setAllowExecuteByBots(true);
-        if (data?.allowExecuteInDM !== undefined)
-            this.setAllowExecuteInDM(true);
-        if (data?.validateOptions !== undefined)
-            this.setValidateOptions(true);
-        if (data?.options !== undefined)
-            this.options = data.options.map(o => (o instanceof MessageCommandOptionBuilder_1.MessageCommandOptionBuilder ? o : new MessageCommandOptionBuilder_1.MessageCommandOptionBuilder(o)));
-    }
-    /**
-     * Sets the command name
-     * @param name Command name
-     */
-    setName(name) {
-        if (!name || typeof name !== 'string' || !name.match(/^[\w-]{1,32}$/))
-            throw new TypeError('name must be a string and match the regex /^[\\w-]{1,32}$/');
-        this.name = name;
-        return this;
-    }
-    /**
-     * Sets the command description
-     * @param description Command description
-     */
-    setDescription(description) {
-        if (!description || typeof description !== 'string')
-            throw new TypeError('description must be a string.');
-        this.description = description;
-        return this;
-    }
-    /**
-     * Add aliases to the command
-     * @param aliases Command aliases
-     */
-    addAliases(...aliases) {
-        aliases = (0, discord_js_1.normalizeArray)(aliases);
-        if (!aliases.length)
-            throw new TypeError('Provide atleast one alias');
-        if (aliases.some(a => !a || typeof a !== 'string' || a.match(/^\s+$/)))
-            throw new TypeError('aliases must be strings and should not contain whitespaces');
-        if (this.name && aliases.some(a => a == this.name))
-            throw new TypeError('alias cannot have same name to its real command name');
-        this.aliases = [...new Set(aliases.map(s => s.toLowerCase()))];
-        return this;
-    }
-    /**
-     * Set if command can be executed in dms
-     * @param allowExecuteInDM `true` if the command can execute in DMs
-     */
-    setAllowExecuteInDM(allowExecuteInDM) {
-        if (typeof allowExecuteInDM !== 'boolean')
-            throw new TypeError('allowExecuteInDM must be a boolean.');
-        this.allowExecuteInDM = allowExecuteInDM;
-        return this;
-    }
-    /**
-     * Allow command to be executed by bots
-     * @param allowExecuteByBots `true` if the command can be executed by bots
-     */
-    setAllowExecuteByBots(allowExecuteByBots) {
-        if (typeof allowExecuteByBots !== 'boolean')
-            throw new TypeError('allowExecuteByBots must be a boolean.');
-        this.allowExecuteByBots = allowExecuteByBots;
-        return this;
-    }
-    /**
-     * Add option to the command
-     * @param option Message option builder
-     */
-    addOption(option) {
-        if (!option)
-            throw new TypeError('option must be a MessageOption.');
-        option = typeof option === 'function' ? option(new MessageCommandOptionBuilder_1.MessageCommandOptionBuilder()) : option;
-        if (this.options.find(o => o.name === option.name))
-            throw new TypeError('option with name "' + option.name + '" already exists.');
-        if (this.options.length > 0 && !this.options[this.options.length - 1 < 0 ? 0 : this.options.length - 1].required && option.required)
-            throw new TypeError('All required options must be before optional options.');
-        this.options.push(option);
-        return this;
-    }
-    /**
-     * Validate options before executing
-     * @param validateOptions `true` if the command options needs to be validated before executing
-     */
-    setValidateOptions(validateOptions) {
-        if (typeof validateOptions !== 'boolean')
-            throw new TypeError('validateOptions must be a boolean.');
-        this.validateOptions = validateOptions;
-        return this;
-    }
-    setCooldown(cooldown) {
-        this.cooldown = cooldown;
-        return this;
-    }
-    setRequiredBotPermissions(...permissions) {
-        this.requiredBotPermissions = (0, discord_js_1.normalizeArray)(permissions);
-        return this;
-    }
-    setRequiredMemberPermissions(...permissions) {
-        this.requiredMemberPermissions = (0, discord_js_1.normalizeArray)(permissions);
-        return this;
-    }
-    setHalt(halt) {
-        this.halt = halt ?? undefined;
-        return this;
-    }
-    setExecute(execute) {
-        if (!execute || typeof execute !== 'function')
-            throw new TypeError('execute must be a function.');
-        this.execute = execute;
-        return this;
-    }
-    setMetadata(metadata) {
-        this.metadata = metadata;
-        return this;
-    }
-    /**
-     * Returns JSON object of this builder
-     */
-    toJSON() {
-        return {
-            type: this.type,
-            name: this.name,
-            description: this.description,
-            aliases: this.aliases,
-            cooldown: this.cooldown,
-            requiredBotPermissions: this.requiredBotPermissions,
-            requiredMemberPermissions: this.requiredMemberPermissions,
-            halt: this.halt,
-            execute: this.execute,
-            metadata: this.metadata,
-            allowExecuteByBots: this.allowExecuteByBots,
-            allowExecuteInDM: this.allowExecuteInDM,
-            validateOptions: this.validateOptions,
-            options: this.options.map(o => o.toJSON()),
-        };
-    }
-    /**
-     * Resolve message command data/builder
-     * @param commandData Command data to resolve
-     */
-    static resolveMessageCommand(commandData) {
-        return this.isMessageCommandBuilder(commandData) ? commandData : new MessageCommandBuilder(commandData);
-    }
-    /**
-     * Is a message command builder
-     * @param builder data to check
-     */
-    static isMessageCommandBuilder(builder) {
-        return builder instanceof MessageCommandBuilder;
-    }
-    /**
-     * Is a message command execute data
-     * @param executeData data to check
-     */
-    static isMessageCommandExecuteData(executeData) {
-        return executeData.builder !== undefined && this.isMessageCommandBuilder(executeData.builder);
-    }
-}
-exports.MessageCommandBuilder = MessageCommandBuilder;
-/**
- * Validate message command options
- * @param builder Command builder
- * @param options Parsed command args
- */
-async function validateMessageCommandOptions(builder, options) {
-    const args = options.args || [];
-    const required = builder.options.filter(o => o.required);
-    const optional = builder.options.filter(o => !o.required);
-    const allOptions = [...required, ...optional];
-    const result = [];
-    let i = 0;
-    for (const option of allOptions) {
-        const arg = args[i];
-        const value = {
-            name: option.name,
-            value: arg ?? undefined,
-            required: option.required,
-            invalid: false,
-            missing: false,
-        };
-        if (arg == undefined && option.required) {
-            value.missing = true;
-            result.push(value);
-            continue;
-        }
-        if (arg == undefined && !option.required) {
-            result.push(value);
-            continue;
-        }
-        const validate = option.validator ? await Promise.resolve(option.validator(arg)) : true;
-        if (!validate)
-            value.invalid = true;
-        result.push(value);
-        i++;
-    }
-    return new MessageCommandOptionManager_1.MessageCommandOptionManager(...result);
-}
-exports.validateMessageCommandOptions = validateMessageCommandOptions;

package/dist/cjs/reciple/classes/managers/ClientModuleManager.js

@@ -1,193 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ClientModuleManager = void 0;
-const crypto_1 = require("crypto");
-const discord_js_1 = require("discord.js");
-const fs_1 = require("fs");
-const path_1 = __importDefault(require("path"));
-const wildcard_match_1 = __importDefault(require("wildcard-match"));
-const flags_1 = require("../../flags");
-const builders_1 = require("../../types/builders");
-const util_1 = require("../../util");
-const version_1 = require("../../version");
-const MessageCommandBuilder_1 = require("../builders/MessageCommandBuilder");
-const SlashCommandBuilder_1 = require("../builders/SlashCommandBuilder");
-class ClientModuleManager {
-    constructor(options) {
-        this.modules = new discord_js_1.Collection();
-        this.client = options.client;
-        options.modules?.forEach(m => {
-            if (!m.id)
-                m.id = (0, crypto_1.randomUUID)();
-            this.modules.set(m.id, this.resolveModule(m));
-        });
-    }
-    async startModulesFromFiles(options) {
-        const modules = await this.resolveModulesFromFiles(options);
-        for (const module_ of modules) {
-            try {
-                await this.startModule(module_);
-            }
-            catch (err) {
-                if (options.dontSkipError)
-                    throw err;
-                if (!this.client.isClientLogsSilent)
-                    this.client.logger.err(`Cannot start module ${ClientModuleManager.getModuleDisplayId(module_)}:`, err);
-            }
-        }
-        return modules;
-    }
-    async resolveModulesFromFiles(options) {
-        const modules = [];
-        const isVersionCheckDisabled = options.disabeVersionCheck || this.client.config.disableVersionCheck;
-        for (const file of options.files) {
-            const moduleFileName = path_1.default.basename(file);
-            const moduleDirPath = path_1.default.dirname(file);
-            const id = (0, crypto_1.randomUUID)();
-            let script;
-            try {
-                const resolveModuleFile = await Promise.resolve().then(() => __importStar(require(file)));
-                script = resolveModuleFile?.default ?? resolveModuleFile;
-                const module_ = this.resolveModule({
-                    id,
-                    script,
-                    info: {
-                        filename: moduleFileName,
-                        path: moduleDirPath,
-                    },
-                }, isVersionCheckDisabled);
-                modules.push(module_);
-                if (!this.client.isClientLogsSilent)
-                    this.client.logger.log(`Resolved ${file}`);
-            }
-            catch (err) {
-                if (options.dontSkipError)
-                    throw err;
-                if (!this.client.isClientLogsSilent)
-                    this.client.logger.err(`Cannot resolve module file ${file}:`, err);
-            }
-        }
-        return modules;
-    }
-    resolveScriptCommands(...modules) {
-        const resolvedCommands = [];
-        for (const script of (0, discord_js_1.normalizeArray)(modules)) {
-            const commands = [];
-            if (Array.isArray(script?.commands)) {
-                for (const command of script.commands) {
-                    if (command.type === builders_1.CommandBuilderType.MessageCommand) {
-                        commands.push(MessageCommandBuilder_1.MessageCommandBuilder.resolveMessageCommand(command));
-                    }
-                    else if (command.type === builders_1.CommandBuilderType.SlashCommand) {
-                        commands.push(SlashCommandBuilder_1.SlashCommandBuilder.resolveSlashCommand(command));
-                    }
-                }
-            }
-            const invalidBuilders = commands.some(c => !(0, util_1.validateCommandBuilder)(c));
-            if (invalidBuilders)
-                throw new Error(`Module script commands contains a command builder without name or option name`);
-            resolvedCommands.push({
-                script,
-                commands,
-            });
-        }
-        return resolvedCommands;
-    }
-    async loadAll(registerApplicationCommands, ...registerApplicationCommandsGuilds) {
-        await Promise.all(this.modules.map(async (m) => {
-            if (typeof m.script?.onLoad === 'function') {
-                try {
-                    await Promise.resolve(m.script.onLoad(this.client)).catch(err => {
-                        throw err;
-                    });
-                }
-                catch (err) {
-                    this.modules.delete(m.id);
-                    if (!this.client.isClientLogsSilent)
-                        this.client.logger.error(`Error loading ${m.info.filename ?? 'unknown module'}:`, err);
-                    return;
-                }
-            }
-            this.client.commands.add(m.commands);
-            if (!this.client.isClientLogsSilent)
-                this.client.logger.log(`Loaded module: ${ClientModuleManager.getModuleDisplayId(m)}`);
-        }));
-        if (!this.client.isClientLogsSilent) {
-            this.client.logger.info(`${this.modules.size} modules loaded.`);
-            this.client.logger.info(`${this.client.commands.messageCommands.size} message commands loaded.`);
-            this.client.logger.info(`${this.client.commands.slashCommands.size} slash commands loaded.`);
-        }
-        if (registerApplicationCommands)
-            this.client.commands.registerApplicationCommands((0, discord_js_1.normalizeArray)(registerApplicationCommandsGuilds));
-    }
-    async startModule(mod) {
-        let err;
-        const identifier = ClientModuleManager.getModuleDisplayId(mod);
-        if (!this.client.isClientLogsSilent)
-            this.client.logger.log(`Starting Module: ${identifier}`);
-        const start = await Promise.resolve(mod.script.onStart(this.client)).catch(e => (err = e));
-        if (err)
-            throw err;
-        if (!start)
-            throw new Error(`Module ${identifier} returned 'false' on start`);
-        this.modules.set(mod.id, mod);
-    }
-    resolveModule(mod, disabeVersionCheck) {
-        const identifier = ClientModuleManager.getModuleDisplayId(mod);
-        if (!disabeVersionCheck && !mod?.script?.versions?.length)
-            throw new Error(`Module ${identifier} does not contain supported versions`);
-        if (typeof mod.script?.onStart !== 'function')
-            throw new Error(`Module ${identifier} does not have a valid 'onStart' method`);
-        const versions = (0, discord_js_1.normalizeArray)([mod.script.versions]);
-        const commands = this.resolveScriptCommands(mod.script)[0].commands;
-        if (!disabeVersionCheck && !versions.some(v => (0, version_1.isSupportedVersion)(v, version_1.version)))
-            throw new Error(`Module ${identifier} does not support 'reciple@${version_1.rawVersion}'`);
-        return {
-            ...mod,
-            commands,
-        };
-    }
-    async getModuleFiles(...folders) {
-        const modules = [];
-        for (const dir of (0, discord_js_1.normalizeArray)(folders).length ? (0, discord_js_1.normalizeArray)(folders) : (0, discord_js_1.normalizeArray)([this.client.config.modulesFolder])) {
-            if (!(0, fs_1.existsSync)(dir))
-                (0, fs_1.mkdirSync)(dir, { recursive: true });
-            if (!(0, fs_1.lstatSync)(dir).isDirectory())
-                continue;
-            modules.push(...(0, fs_1.readdirSync)(dir)
-                .map(file => path_1.default.join(flags_1.cwd, dir, file))
-                .filter(file => file.endsWith('.js') || file.endsWith('.cjs')));
-        }
-        return modules.filter(file => !this.client.config.ignoredFiles.some(ignored => (0, wildcard_match_1.default)(ignored)(path_1.default.basename(file))));
-    }
-    static getModuleDisplayId(mod) {
-        return mod.info.path && mod.info.filename ? path_1.default.join(mod.info.path, mod.info.filename) : mod.id;
-    }
-}
-exports.ClientModuleManager = ClientModuleManager;

package/dist/cjs/reciple/types/builders.js

@@ -1,11 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CommandBuilderType = void 0;
-/**
- * Types of command builders
- */
-var CommandBuilderType;
-(function (CommandBuilderType) {
-    CommandBuilderType[CommandBuilderType["MessageCommand"] = 0] = "MessageCommand";
-    CommandBuilderType[CommandBuilderType["SlashCommand"] = 1] = "SlashCommand";
-})(CommandBuilderType = exports.CommandBuilderType || (exports.CommandBuilderType = {}));

package/dist/cjs/reciple/util.js

@@ -1,32 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.validateCommandBuilder = exports.deprecationWarning = exports.isClass = void 0;
-const builders_1 = require("./types/builders");
-/**
- * Check if an object is a class
- * @param object Object to identify
- */
-function isClass(object) {
-    const isClassConstructor = object.constructor && object.constructor.toString().substring(0, 5) === 'class';
-    if (object.prototype === undefined)
-        return isClassConstructor;
-    const isPrototypeClassConstructor = object.prototype.constructor && object.prototype.constructor.toString && object.prototype.constructor.toString().substring(0, 5) === 'class';
-    return isClassConstructor || isPrototypeClassConstructor;
-}
-exports.isClass = isClass;
-/**
- * Emit process warning about deprecated method/function
- * @param content Warning content
- */
-function deprecationWarning(content) {
-    process.emitWarning(content, 'DeprecationWarning');
-}
-exports.deprecationWarning = deprecationWarning;
-function validateCommandBuilder(command) {
-    if (!command.name)
-        return false;
-    if (command.type === builders_1.CommandBuilderType.MessageCommand && command.options.length && command.options.some(o => !o.name))
-        return false;
-    return true;
-}
-exports.validateCommandBuilder = validateCommandBuilder;

package/dist/types/reciple/classes/managers/ClientCommandManager.d.ts

@@ -1,37 +0,0 @@
-import { ApplicationCommandData, Collection, GuildResolvable, RestOrArray } from 'discord.js';
-import { AnyCommandBuilder, AnyCommandData, AnySlashCommandBuilder, CommandBuilderType, MessageCommandData, SlashCommandData } from '../../types/builders';
-import { MessageCommandBuilder } from '../builders/MessageCommandBuilder';
-import { SlashCommandBuilder } from '../builders/SlashCommandBuilder';
-import { RecipleClient } from '../RecipleClient';
-import { ApplicationCommandBuilder } from './ApplicationCommandManager';
-export interface ClientCommandManagerOptions {
-    client: RecipleClient;
-    messageCommands?: (MessageCommandBuilder | MessageCommandData)[];
-    slashCommands?: (AnySlashCommandBuilder | SlashCommandData)[];
-}
-export declare class ClientCommandManager {
-    readonly client: RecipleClient;
-    readonly slashCommands: Collection<string, AnySlashCommandBuilder>;
-    readonly messageCommands: Collection<string, MessageCommandBuilder>;
-    readonly additionalApplicationCommands: (ApplicationCommandBuilder | ApplicationCommandData)[];
-    get applicationCommandsSize(): number;
-    constructor(options: ClientCommandManagerOptions);
-    /**
-     * Add command to command manager
-     * @param commands Any command data or builder
-     */
-    add(...commands: RestOrArray<AnyCommandBuilder | AnyCommandData>): this;
-    /**
-     * Get command builder by name or alias if it's a message command
-     * @param command Command name
-     * @param type Command type
-     */
-    get(command: string, type?: undefined): AnyCommandBuilder | undefined;
-    get(command: string, type?: CommandBuilderType.MessageCommand): MessageCommandBuilder | undefined;
-    get(command: string, type?: CommandBuilderType.SlashCommand): SlashCommandBuilder | undefined;
-    /**
-     * Register application commands
-     * @param guilds Register application commands to guilds
-     */
-    registerApplicationCommands(...guilds: RestOrArray<GuildResolvable>): Promise<this>;
-}

package/dist/types/reciple/classes/managers/ClientModuleManager.d.ts

@@ -1,79 +0,0 @@
-import { Collection, GuildResolvable, RestOrArray } from 'discord.js';
-import { AnyCommandBuilder, AnyCommandData } from '../../types/builders';
-import { ModuleManagerResolveFilesOptions } from '../../types/paramOptions';
-import { RecipleClient } from '../RecipleClient';
-/**
- * Reciple script object
- */
-export interface RecipleScript {
-    /**
-     * Supported reciple versions
-     */
-    versions: string | string[];
-    /**
-     * Module commands
-     */
-    commands?: (AnyCommandBuilder | AnyCommandData)[];
-    /**
-     * Action on module start
-     * @param client Bot client
-     */
-    onStart(client: RecipleClient<false>): boolean | Promise<boolean>;
-    /**
-     * Action on bot ready
-     * @param client Bot client
-     */
-    onLoad?(client: RecipleClient<true>): void | Promise<void>;
-}
-/**
- * Reciple module object
- */
-export interface RecipleModule {
-    /**
-     * Module Id
-     */
-    id: string;
-    /**
-     * Module script
-     */
-    script: RecipleScript;
-    /**
-     * Module local information
-     */
-    info: {
-        /**
-         * Module file name
-         */
-        filename?: string;
-        /**
-         * Module local file path
-         */
-        path?: string;
-    };
-}
-export interface ResolvedModule extends RecipleModule {
-    commands: AnyCommandBuilder[];
-}
-export interface ResolvedScriptCommands {
-    script: RecipleScript;
-    commands: AnyCommandBuilder[];
-}
-export interface ClientModuleManagerOptions {
-    client: RecipleClient;
-    modules?: (RecipleModule & {
-        id?: string;
-    })[];
-}
-export declare class ClientModuleManager {
-    readonly client: RecipleClient;
-    readonly modules: Collection<string, ResolvedModule>;
-    constructor(options: ClientModuleManagerOptions);
-    startModulesFromFiles(options: ModuleManagerResolveFilesOptions): Promise<ResolvedModule[]>;
-    resolveModulesFromFiles(options: ModuleManagerResolveFilesOptions): Promise<ResolvedModule[]>;
-    resolveScriptCommands(...modules: RestOrArray<RecipleScript>): ResolvedScriptCommands[];
-    loadAll(registerApplicationCommands?: boolean, ...registerApplicationCommandsGuilds: RestOrArray<GuildResolvable>): Promise<void>;
-    startModule(mod: ResolvedModule): Promise<void>;
-    resolveModule(mod: RecipleModule, disabeVersionCheck?: boolean): ResolvedModule;
-    getModuleFiles(...folders: RestOrArray<string>): Promise<string[]>;
-    static getModuleDisplayId(mod: RecipleModule): string;
-}

package/dist/types/reciple/logger.d.ts

@@ -1,8 +0,0 @@
-import { Logger } from 'fallout-utility';
-/**
- * Create new logger
- * @param stringifyJSON stringify json objects in console
- * @param debugmode display debug messages
- * @param colorizeMessage add logger colours to messages
- */
-export declare function createLogger(stringifyJSON: boolean, debugmode?: boolean, colorizeMessage?: boolean): Logger;

package/docs/README.md

@@ -1 +0,0 @@
-# [VIEW DOCS](https://reciple.js.org/#/docs)