com.wallstop-studios.unity-helpers 1.0.2 → 2.0.0-rc01

package/Runtime/Binaries/System.Text.Json.xml.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: efe062ce4d8a81c4591b1d77e0e28d29
+TextScriptImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Runtime/Binaries.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 0c99a4aad696c5a42a04531fd9d52cc8
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Runtime/Core/Serialization/JsonConverters/Vector2Converter.cs

@@ -1,32 +1,65 @@
 namespace UnityHelpers.Core.Serialization.JsonConverters
 {
-    using Extension;
-    using Newtonsoft.Json;
-    using Newtonsoft.Json.Linq;
     using System;
+    using System.Text.Json;
+    using System.Text.Json.Serialization;
     using UnityEngine;
 
-    public sealed class Vector2Converter : JsonConverter
+    public sealed class Vector2Converter : JsonConverter<Vector2>
     {
-        public static readonly Vector2Converter Instance = new Vector2Converter();
+        public static readonly Vector2Converter Instance = new();
 
         private Vector2Converter() { }
 
-        public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
+        public override Vector2 Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
         {
-            JToken.FromObject(((Vector2)value).ToJsonString()).WriteTo(writer);
-        }
+            if (reader.TokenType != JsonTokenType.StartObject)
+            {
+                throw new JsonException($"Invalid token type {reader.TokenType}");
+            }
 
-        public override object ReadJson(JsonReader reader, Type objectType, object existingValue,
-            JsonSerializer serializer)
-        {
-            object instance = serializer.Deserialize(reader);
-            return JsonConvert.DeserializeObject<Vector2>(instance.ToString());
+            float x = 0, y = 0;
+
+            while (reader.Read())
+            {
+                if (reader.TokenType == JsonTokenType.EndObject)
+                {
+                    return new Vector2(x, y);
+                }
+
+                if (reader.TokenType == JsonTokenType.PropertyName)
+                {
+                    string propertyName = reader.GetString();
+                    reader.Read();
+                    switch (propertyName)
+                    {
+                        case "x":
+                        {
+                            x = reader.GetSingle();
+                            break;
+                        }
+                        case "y":
+                        {
+                            y = reader.GetSingle();
+                            break;
+                        }
+                        default:
+                        {
+                            throw new JsonException($"Unknown property: {propertyName}");
+                        }
+                    }
+                }
+            }
+
+            throw new JsonException("Incomplete JSON for Vector2");
         }
 
-        public override bool CanConvert(Type objectType)
+        public override void Write(Utf8JsonWriter writer, Vector2 value, JsonSerializerOptions options)
         {
-            return objectType == typeof(Vector2);
+            writer.WriteStartObject();
+            writer.WriteNumber("x", value.x);
+            writer.WriteNumber("y", value.y);
+            writer.WriteEndObject();
         }
     }
-}
+}

package/Runtime/Core/Serialization/JsonConverters/Vector3Converter.cs

@@ -1,32 +1,71 @@
 namespace UnityHelpers.Core.Serialization.JsonConverters
 {
-    using Extension;
-    using Newtonsoft.Json;
-    using Newtonsoft.Json.Linq;
     using System;
     using UnityEngine;
+    using System.Text.Json;
+    using System.Text.Json.Serialization;
 
-    public sealed class Vector3Converter : JsonConverter
+    public sealed class Vector3Converter : JsonConverter<Vector3>
     {
-        public static readonly Vector3Converter Instance = new Vector3Converter();
+        public static readonly Vector3Converter Instance = new();
 
         private Vector3Converter() { }
 
-        public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
+        public override Vector3 Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
         {
-            JToken.FromObject(((Vector3)value).ToJsonString()).WriteTo(writer);
-        }
+            if (reader.TokenType != JsonTokenType.StartObject)
+            {
+                throw new JsonException($"Invalid token type {reader.TokenType}");
+            }
 
-        public override object ReadJson(JsonReader reader, Type objectType, object existingValue,
-            JsonSerializer serializer)
-        {
-            object instance = serializer.Deserialize(reader);
-            return JsonConvert.DeserializeObject<Vector3>(instance.ToString());
+            float x = 0, y = 0, z = 0;
+
+            while (reader.Read())
+            {
+                if (reader.TokenType == JsonTokenType.EndObject)
+                {
+                    return new Vector3(x, y, z);
+                }
+
+                if (reader.TokenType == JsonTokenType.PropertyName)
+                {
+                    string propertyName = reader.GetString();
+                    reader.Read();
+                    switch (propertyName)
+                    {
+                        case "x":
+                        {
+                            x = reader.GetSingle();
+                            break;
+                        }
+                        case "y":
+                        {
+                            y = reader.GetSingle();
+                            break;
+                        }
+                        case "z":
+                        {
+                            z = reader.GetSingle();
+                            break;
+                        }
+                        default:
+                        {
+                            throw new JsonException($"Unknown property: {propertyName}");
+                        }
+                    }
+                }
+            }
+
+            throw new JsonException("Incomplete JSON for Vector3");
         }
 
-        public override bool CanConvert(Type objectType)
+        public override void Write(Utf8JsonWriter writer, Vector3 value, JsonSerializerOptions options)
         {
-            return objectType == typeof(Vector3);
+            writer.WriteStartObject();
+            writer.WriteNumber("x", value.x);
+            writer.WriteNumber("y", value.y);
+            writer.WriteNumber("z", value.z);
+            writer.WriteEndObject();
         }
     }
-}
+}

package/Runtime/Core/Serialization/Serializer.cs

@@ -4,26 +4,44 @@
     using System.ComponentModel;
     using Extension;
     using JsonConverters;
-    using Newtonsoft.Json;
-    using Newtonsoft.Json.Converters;
     using System.IO;
     using System.Runtime.Serialization.Formatters.Binary;
     using System.Text;
-    using UnityEngine;
+    using System.Text.Json;
+    using System.Text.Json.Serialization;
 
     internal static class SerializerEncoding
     {
-        public static readonly Encoding Encoding = Encoding.Default;
+        public static readonly Encoding Encoding;
+        public static readonly JsonSerializerOptions NormalJsonOptions;
+        public static readonly JsonSerializerOptions PrettyJsonOptions;
 
-        public static readonly JsonConverter[] Converters =
-            {new StringEnumConverter(), Vector3Converter.Instance, Vector2Converter.Instance};
-
-        public static readonly JsonSerializerSettings Settings = new JsonSerializerSettings
+        static SerializerEncoding()
         {
-            ReferenceLoopHandling = ReferenceLoopHandling.Ignore,
-            Converters = Converters
-        };
-        
+            Encoding = Encoding.UTF8;
+            NormalJsonOptions = new JsonSerializerOptions
+            {
+                IncludeFields = true,
+                Converters =
+                {
+                    new JsonStringEnumConverter(),
+                    Vector3Converter.Instance,
+                    Vector2Converter.Instance
+                },
+            };
+
+            PrettyJsonOptions = new JsonSerializerOptions
+            {
+                IncludeFields = true,
+                Converters =
+                {
+                    new JsonStringEnumConverter(),
+                    Vector3Converter.Instance,
+                    Vector2Converter.Instance
+                },
+                WriteIndented = true,
+            };
+        }
     }
 
     public enum SerializationType
@@ -43,7 +61,8 @@
                 case SerializationType.Protobuf:
                     return ProtoDeserialize<T>(serialized);
                 default:
-                    throw new InvalidEnumArgumentException(nameof(serializationType), (int)serializationType, typeof(SerializationType));
+                    throw new InvalidEnumArgumentException(
+                        nameof(serializationType), (int)serializationType, typeof(SerializationType));
             }
         }
 
@@ -56,7 +75,8 @@
                 case SerializationType.Protobuf:
                     return ProtoSerialize(instance);
                 default:
-                    throw new InvalidEnumArgumentException(nameof(serializationType), (int)serializationType, typeof(SerializationType));
+                    throw new InvalidEnumArgumentException(
+                        nameof(serializationType), (int)serializationType, typeof(SerializationType));
             }
         }
 
@@ -75,6 +95,7 @@
             binaryFormatter.Serialize(memoryStream, input);
             return memoryStream.ToArray();
         }
+
         public static T ProtoDeserialize<T>(byte[] data)
         {
             using MemoryStream memoryStream = new(data);
@@ -84,7 +105,7 @@
         public static T ProtoDeserialize<T>(byte[] data, Type type)
         {
             using MemoryStream memoryStream = new(data);
-            return (T) ProtoBuf.Serializer.Deserialize(type, memoryStream);
+            return (T)ProtoBuf.Serializer.Deserialize(type, memoryStream);
         }
 
         public static byte[] ProtoSerialize<T>(T input)
@@ -96,18 +117,26 @@
 
         public static T JsonDeserialize<T>(string data)
         {
-            return JsonConvert.DeserializeObject<T>(data);
+            return JsonSerializer.Deserialize<T>(data, SerializerEncoding.NormalJsonOptions);
         }
 
-        public static byte[] JsonSerialize(object input)
+        public static byte[] JsonSerialize<T>(T input)
         {
             return JsonStringify(input).GetBytes();
         }
 
-        public static string JsonStringify(object input, bool pretty = false)
+        public static string JsonStringify<T>(T input, bool pretty = false)
         {
-            return JsonConvert.SerializeObject(input, pretty ? Formatting.Indented : Formatting.None,
-                SerializerEncoding.Settings);
+            JsonSerializerOptions options =
+                pretty ? SerializerEncoding.PrettyJsonOptions : SerializerEncoding.NormalJsonOptions;
+            if (typeof(T) == typeof(object))
+            {
+                object data = input;
+                Type type = data?.GetType();
+                return JsonSerializer.Serialize(data, data?.GetType(), options);
+            }
+
+            return JsonSerializer.Serialize(input, options);
         }
 
         public static T ReadFromJsonFile<T>(string path)
@@ -116,10 +145,10 @@
             return JsonDeserialize<T>(settingsAsText);
         }
 
-        public static void WriteToJsonFile<T>(T input, string path)
+        public static void WriteToJsonFile<T>(T input, string path, bool pretty = true)
         {
-            string jsonAsText = JsonUtility.ToJson(input);
+            string jsonAsText = JsonStringify(input, pretty);
             File.WriteAllText(path, jsonAsText);
         }
     }
-}
+}