src/core/CommandArgumentParserInterface.ts

/*
* This file is part of SudoBot.
*
* Copyright (C) 2021-2023 OSN Developers.
*
* SudoBot is free software; you can redistribute it and/or modify it
* under the terms of the GNU Affero General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* SudoBot is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with SudoBot. If not, see <https://www.gnu.org/licenses/>.
*/

import { Awaitable, Message } from "discord.js";

export type ParsingState = {
    argv: string[];
    args: string[];
    parsedArgs: Record<string | number, any>;
    index: number;
    currentArg: string | undefined;
    rule: ValidationRule;
    parseOptions: ParseOptions;
    type: ArgumentType;
};

export enum ArgumentType {
    String,
    Number,
    Integer,
    Float,
    User,
    Role,
    Member,
    Channel,
    StringRest,
    Snowflake,
    Link,
    TimeInterval
}

export type ValidationErrorType =
    | "required"
    | "type:invalid"
    | "entity:null"
    | "number:range:min"
    | "number:range:max"
    | "number:range"
    | "time:range:min"
    | "time:range:max"
    | "time:range"
    | "string:length:min"
    | "string:length:max"
    | "string:rest:length:min"
    | "string:rest:length:max"
    | "string:empty";

export type ValidationRuleErrorMessages = { [K in ValidationErrorType]?: string };
export type ValidationRule = {
    types: readonly ArgumentType[];
    optional?: boolean;
    default?: any;
    name?: string;
    errors?: ValidationRuleErrorMessages;
    number?: {
        min?: number;
        max?: number;
    };
    string?: {
        maxLength?: number;
        minLength?: number;
        notEmpty?: boolean;
    };
    time?: {
        unit?: "ms" | "s";
        min?: number;
        max?: number;
    };
    link?: {
        urlObject?: boolean;
    };
    entity?:
        | boolean
        | {
              notNull?: boolean;
          };
};

export type ParseOptions = {
    input: string;
    message?: Message;
    rules: readonly ValidationRule[];
    prefix: string;
};

export enum ParserJump {
    Next,
    Break,
    Steps
}

export type ParseResult<T = any> = {
    jump?: ParserJump;
    steps?: number;
    result?: T;
};

export default interface CommandArgumentParserInterface {
    parse(options: ParseOptions): Awaitable<Record<string | number, any>>;
}
1	/*
2	* This file is part of SudoBot.
3	*
4	* Copyright (C) 2021-2023 OSN Developers.
5	*
6	* SudoBot is free software; you can redistribute it and/or modify it
7	* under the terms of the GNU Affero General Public License as published by
8	* the Free Software Foundation, either version 3 of the License, or
9	* (at your option) any later version.
10	*
11	* SudoBot is distributed in the hope that it will be useful, but
12	* WITHOUT ANY WARRANTY; without even the implied warranty of
13	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14	* GNU Affero General Public License for more details.
15	*
16	* You should have received a copy of the GNU Affero General Public License
17	* along with SudoBot. If not, see <https://www.gnu.org/licenses/>.
18	*/
19
20	import { Awaitable, Message } from "discord.js";
21
22	export type ParsingState = {
23	argv: string[];
24	args: string[];
25	parsedArgs: Record<string \| number, any>;
26	index: number;
27	currentArg: string \| undefined;
28	rule: ValidationRule;
29	parseOptions: ParseOptions;
30	type: ArgumentType;
31	};
32
33	export enum ArgumentType {
34	String,
35	Number,
36	Integer,
37	Float,
38	User,
39	Role,
40	Member,
41	Channel,
42	StringRest,
43	Snowflake,
44	Link,
45	TimeInterval
46	}
47
48	export type ValidationErrorType =
49	\| "required"
50	\| "type:invalid"
51	\| "entity:null"
52	\| "number:range:min"
53	\| "number:range:max"
54	\| "number:range"
55	\| "time:range:min"
56	\| "time:range:max"
57	\| "time:range"
58	\| "string:length:min"
59	\| "string:length:max"
60	\| "string:rest:length:min"
61	\| "string:rest:length:max"
62	\| "string:empty";
63
64	export type ValidationRuleErrorMessages = { [K in ValidationErrorType]?: string };
65	export type ValidationRule = {
66	types: readonly ArgumentType[];
67	optional?: boolean;
68	default?: any;
69	name?: string;
70	errors?: ValidationRuleErrorMessages;
71	number?: {
72	min?: number;
73	max?: number;
74	};
75	string?: {
76	maxLength?: number;
77	minLength?: number;
78	notEmpty?: boolean;
79	};
80	time?: {
81	unit?: "ms" \| "s";
82	min?: number;
83	max?: number;
84	};
85	link?: {
86	urlObject?: boolean;
87	};
88	entity?:
89	\| boolean
90	\| {
91	notNull?: boolean;
92	};
93	};
94
95	export type ParseOptions = {
96	input: string;
97	message?: Message;
98	rules: readonly ValidationRule[];
99	prefix: string;
100	};
101
102	export enum ParserJump {
103	Next,
104	Break,
105	Steps
106	}
107
108	export type ParseResult<T = any> = {
109	jump?: ParserJump;
110	steps?: number;
111	result?: T;
112	};
113
114	export default interface CommandArgumentParserInterface {
115	parse(options: ParseOptions): Awaitable<Record<string \| number, any>>;
116	}