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	rakinar2	577	/*
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			}