fix: use minimal integer encoding and decode fixint bytes

config.v

@@ -37,6 +37,7 @@ struct Config {
 
 pub fn default_config() Config {
 	return Config{
-		write_ext: true
+		write_ext:             true
+		positive_int_unsigned: true
 	}
 }

decode.v

@@ -86,7 +86,7 @@ pub fn (mut d Decoder) decode_to_json[T](src []u8) !string {
 			result << `}`
 		}
 		mp_nil {
-			unsafe { result.push_many('null'.str, 'null'.len) }
+			unsafe { result.push_many(c'null', 'null'.len) }
 		}
 		mp_true, mp_false {
 			mut bool_val := false
@@ -98,6 +98,14 @@ pub fn (mut d Decoder) decode_to_json[T](src []u8) !string {
 			d.decode_float(mut float_val) or { return error('error decoding float: ${err}') }
 			unsafe { result.push_many(float_val.str().str, float_val.str().len) }
 		}
+		mp_pos_fix_int_min...mp_pos_fix_int_max {
+			int_val := int(d.bd)
+			unsafe { result.push_many(int_val.str().str, int_val.str().len) }
+		}
+		mp_neg_fix_int_min...mp_neg_fix_int_max {
+			int_val := int(i8(d.bd))
+			unsafe { result.push_many(int_val.str().str, int_val.str().len) }
+		}
 		mp_u8, mp_u16, mp_u32, mp_u64, mp_i8, mp_i16, mp_i32, mp_i64 {
 			mut int_val := 0
 			d.decode_integer(mut int_val) or { return error('error decoding integer: ${err}') }
@@ -124,6 +132,7 @@ pub fn (mut d Decoder) decode_to_json[T](src []u8) !string {
 			return error('unsupported descriptor byte for conversion to JSON')
 		}
 	}
+
 	return result.bytestr()
 }
 
@@ -170,6 +179,12 @@ pub fn (mut d Decoder) decode[T](data []u8, mut val T) ! {
 pub fn (mut d Decoder) decode_integer[T](mut val T) ! {
 	data := d.buffer
 	match d.bd {
+		mp_pos_fix_int_min...mp_pos_fix_int_max {
+			val = T(d.bd)
+		}
+		mp_neg_fix_int_min...mp_neg_fix_int_max {
+			val = T(i8(d.bd))
+		}
 		mp_u8 {
 			val = T(data[d.pos])
 			d.pos++

encode.v

@@ -37,26 +37,24 @@ pub fn (mut e Encoder) encode[T](data T) []u8 {
 		e.encode_string(data)
 	} $else $if T is bool {
 		e.encode_bool(data)
-	}
-	// TODO: if int encode_int, if uint encode_uint
-	// instead of needing to check each type, also
-	// then we will be using the smallest storage
-	$else $if T is i8 {
-		e.encode_i8(data)
+	} $else $if T is i8 {
+		e.encode_int(i64(data))
 	} $else $if T is i16 {
-		e.encode_i16(data)
+		e.encode_int(i64(data))
 	} $else $if T is int {
-		e.encode_i32(data)
+		e.encode_int(i64(data))
+	} $else $if T is i32 {
+		e.encode_int(i64(data))
 	} $else $if T is i64 {
-		e.encode_i64(data)
+		e.encode_int(data)
 	} $else $if T is u8 {
-		e.encode_u8(data)
+		e.encode_uint(u64(data))
 	} $else $if T is u16 {
-		e.encode_u16(data)
+		e.encode_uint(u64(data))
 	} $else $if T is u32 {
-		e.encode_u32(data)
+		e.encode_uint(u64(data))
 	} $else $if T is u64 {
-		e.encode_u64(data)
+		e.encode_uint(data)
 	} $else $if T is f32 {
 		e.encode_f32(data)
 	} $else $if T is f64 {
@@ -231,6 +229,7 @@ pub fn (mut e Encoder) encode_string(s string) {
 			container_raw_legacy
 		}
 	}
+
 	e.write_container_len(ct, s.len)
 	if s.len > 0 {
 		e.write_string(s)

encode_test.v

@@ -11,20 +11,20 @@ struct Struct {
 
 fn test_encoding() {
 	// Test encoding integers
-	assert msgpack.encode(0) == hex.decode('d200000000')!
-	assert msgpack.encode(42) == hex.decode('d20000002a')!
-	assert msgpack.encode(-123) == hex.decode('d2ffffff85')!
+	assert msgpack.encode(0) == hex.decode('00')!
+	assert msgpack.encode(42) == hex.decode('2a')!
+	assert msgpack.encode(-123) == hex.decode('d085')!
 
 	// Test encoding strings
 	assert msgpack.encode('hello') == hex.decode('a568656c6c6f')!
 	assert msgpack.encode('') == hex.decode('a0')!
 
 	// Test encoding arrays
 	// assert msgpack.encode([]) == hex.decode('90')!
-	assert msgpack.encode([0]) == hex.decode('91d200000000')!
+	assert msgpack.encode([0]) == hex.decode('9100')!
 	assert msgpack.encode([0.0]) == hex.decode('91cb0000000000000000')!
 	assert msgpack.encode(['']) == hex.decode('91a0')!
-	assert msgpack.encode([1, 2, 3]) == hex.decode('93d200000001d200000002d200000003')! // REVIEW
+	assert msgpack.encode([1, 2, 3]) == hex.decode('93010203')!
 
 	// Test encoding maps
 	assert msgpack.encode({
@@ -33,7 +33,7 @@ fn test_encoding() {
 	}) == hex.decode('82a46e616d65a44a6f686ea3616765a23330')!
 
 	// Test encoding struct
-	assert msgpack.encode(Struct{'John', 30}) == hex.decode('82a161a44a6f686ea162d20000001e')!
+	assert msgpack.encode(Struct{'John', 30}) == hex.decode('82a161a44a6f686ea1621e')!
 	// assert msgpack.encode({}) == hex.decode('80')!
 
 	// Test encoding booleans