fix: fixed a bug with resolveMinMax not being translated

src/lib/structures/Serializer.ts

@@ -65,14 +65,19 @@ export abstract class Serializer extends AliasPiece {
 	protected static minOrMax(value: number, { minimum, maximum, inclusive, key }: SchemaEntry, language: Language): boolean {
 		if (minimum && maximum) {
 			if ((value >= minimum && value <= maximum && inclusive) || (value > minimum && value < maximum && !inclusive)) return true;
-			if (minimum === maximum) throw new RangeError(language.get('resolverMinmaxExactly', { key, min: minimum, inclusive }));
-			throw new RangeError(language.get('resolverMinmaxBoth', { key, min: minimum, max: maximum, inclusive }));
+			if (minimum === maximum)
+				throw new RangeError(
+					language.get(inclusive ? 'resolverMinmaxExactlyInclusive' : 'resolverMinmaxExactlyExclusive', { name: key, min: minimum })
+				);
+			throw new RangeError(
+				language.get(inclusive ? 'resolverMinmaxBothInclusive' : 'resolverMinmaxBothExclusive', { name: key, min: minimum, max: maximum })
+			);
 		} else if (minimum) {
 			if ((value >= minimum && inclusive) || (value > minimum && !inclusive)) return true;
-			throw new RangeError(language.get('resolverMinmaxMin', { key, min: minimum, inclusive }));
+			throw new RangeError(language.get(inclusive ? 'resolverMinmaxMinInclusive' : 'resolverMinmaxMinExclusive', { name: key, min: minimum }));
 		} else if (maximum) {
 			if ((value <= maximum && inclusive) || (value < maximum && !inclusive)) return true;
-			throw new RangeError(language.get('resolverMinmaxMax', { key, max: maximum, inclusive }));
+			throw new RangeError(language.get(inclusive ? 'resolverMinmaxMaxInclusive' : 'resolverMinmaxMaxExclusive', { name: key, max: maximum }));
 		}
 		return true;
 	}

tests/lib/MockLanguage.ts

@@ -15,14 +15,22 @@ export class MockLanguage extends Language {
 				`[settingGatewayDuplicateValue]: ${path} ${value}`,
 			settingGatewayInvalidFilteredValue: ({ path, value }: { path: string; value: string }): string =>
 				`[settingGatewayInvalidFilteredValue]: ${path} ${value}`,
-			resolverMinmaxExactly: ({ key, min, inclusive }: { key: string; min: number; inclusive: boolean }): string =>
-				`[resolverMinmaxExactly]: ${key} ${min} ${inclusive}`,
-			resolverMinmaxBoth: ({ key, min, max, inclusive }: { key: string; min: number; max: number; inclusive: boolean }): string =>
-				`[resolverMinmaxBoth]: ${key} ${min} ${max} ${inclusive}`,
-			resolverMinmaxMin: ({ key, min, inclusive }: { key: string; min: number; inclusive: number }): string =>
-				`[resolverMinmaxMin]: ${key} ${min} ${inclusive}`,
-			resolverMinmaxMax: ({ key, max, inclusive }: { key: string; max: number; inclusive: number }): string =>
-				`[resolverMinmaxMax]: ${key} ${max} ${inclusive}`
+			resolverMinmaxExactlyInclusive: ({ key, min }: { key: string; min: number; inclusive: boolean }): string =>
+				`[resolverMinmaxExactly]: ${key} ${min}`,
+			resolverMinmaxExactlyExclusive: ({ key, min }: { key: string; min: number; inclusive: boolean }): string =>
+				`[resolverMinmaxExactly]: ${key} ${min}`,
+			resolverMinmaxBothInclusive: ({ key, min, max }: { key: string; min: number; max: number; inclusive: boolean }): string =>
+				`[resolverMinmaxBoth]: ${key} ${min} ${max}`,
+			resolverMinmaxBothExclusive: ({ key, min, max }: { key: string; min: number; max: number; inclusive: boolean }): string =>
+				`[resolverMinmaxBoth]: ${key} ${min} ${max}`,
+			resolverMinmaxMinInclusive: ({ key, min }: { key: string; min: number; inclusive: number }): string =>
+				`[resolverMinmaxMin]: ${key} ${min}`,
+			resolverMinmaxMinExclusive: ({ key, min }: { key: string; min: number; inclusive: number }): string =>
+				`[resolverMinmaxMin]: ${key} ${min}`,
+			resolverMinmaxMaxInclusive: ({ key, max }: { key: string; max: number; inclusive: number }): string =>
+				`[resolverMinmaxMax]: ${key} ${max}`,
+			resolverMinmaxMaxExclusive: ({ key, max }: { key: string; max: number; inclusive: number }): string =>
+				`[resolverMinmaxMax]: ${key} ${max}`
 		};
 	}
 }