📦 0.6.2 Update

JonathanMCarter · JonathanMCarter · commit 8ca2eac64087 · 2025-08-03T17:36:07.000+01:00
- Fix for a single issue on downloading arrays
diff --git a/Carter Games/Notion Database To Unity/Code/Runtime/Notion/Notion Database Handling/Value Conversion/NotionPropertyValueHandler.cs b/Carter Games/Notion Database To Unity/Code/Runtime/Notion/Notion Database Handling/Value Conversion/NotionPropertyValueHandler.cs
@@ -1,17 +1,17 @@
 ﻿/*
  * Copyright (c) 2025 Carter Games
- * 
+ *
  * Permission is hereby granted, free of charge, to any person obtaining a copy
  * of this software and associated documentation files (the "Software"), to deal
  * in the Software without restriction, including without limitation the rights
  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  * copies of the Software, and to permit persons to whom the Software is
  * furnished to do so, subject to the following conditions:
- * 
+ *
  * The above copyright notice and this permission notice shall be included in
  * all copies or substantial portions of the Software.
- * 
- *    
+ *
+ *
  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
@@ -37,22 +37,18 @@ namespace CarterGames.NotionData
     public static class NotionPropertyValueHandler
     {
         /// <summary>
-        /// Gets the value in this property its type if possible. 
+        /// Gets the value in this property its type if possible.
         /// </summary>
         /// <param name="property">The notion property to read from.</param>
         /// <param name="fieldType">The field type to match.</param>
         /// <param name="value">The object value assigned.</param>
         /// <returns>If the parsing was successful.</returns>
         public static bool TryGetValueAs(NotionProperty property, Type fieldType, out object value)
         {
-            Debug.Log(fieldType);
-            Debug.Log(fieldType.IsArray);
- 
-            
             if (fieldType.IsArray)
             {
                 if (TryParseAsArray(property, fieldType, out value)) return true;
-                
+
                 if (fieldType.IsEnum)
                 {
                     if (TryParseEnumOrEnumFlags(property, fieldType, out value)) return true;
@@ -62,40 +58,39 @@ public static bool TryGetValueAs(NotionProperty property, Type fieldType, out ob
             if (fieldType.IsGenericList())
             {
                 if (TryParseAsList(property, fieldType, out value)) return true;
-                
+
                 if (fieldType.IsEnum)
                 {
                     if (TryParseEnumOrEnumFlags(property, fieldType, out value)) return true;
                 }
             }
-            
-            
+
+
             if (TryParseAsPrimitive(property, fieldType, out value)) return true;
-            
-            
+
+
             if (fieldType.IsEnum)
             {
                 if (TryParseEnumOrEnumFlags(property, fieldType, out value)) return true;
             }
-            
-            
+
+
             if (TryParseWrapper(property, fieldType, out value)) return true;
-            
-            Debug.Log(property.PropertyName);
-            
+
             if (fieldType.IsClass)
             {
+                Debug.Log(property.JsonValue);
                 value = JsonUtility.FromJson(property.JsonValue, fieldType);
                 return value != null;
             }
 
             Debug.LogError("Couldn't parse data");
             return false;
         }
-        
-        
+
+
         /// <summary>
-        /// Gets the value in this property its type if possible (Only as wrapper). 
+        /// Gets the value in this property its type if possible (Only as wrapper).
         /// </summary>
         /// <param name="property">The notion property to read from.</param>
         /// <param name="fieldType">The field type to match.</param>
@@ -104,16 +99,16 @@ public static bool TryGetValueAs(NotionProperty property, Type fieldType, out ob
         public static bool TryGetValueAsWrapper(NotionProperty property, Type fieldType, out object value)
         {
             if (TryParseWrapper(property, fieldType, out value)) return true;
-            
+
             Debug.LogError("Couldn't parse data");
             return false;
         }
 
-        
+
         private static bool TryParseAsPrimitive(NotionProperty property, Type fieldType, out object result)
         {
             result = null;
-            
+
             try
             {
                 switch (fieldType.Name)
@@ -137,15 +132,15 @@ private static bool TryParseAsPrimitive(NotionProperty property, Type fieldType,
 
                 return result != null;
             }
-#pragma warning disable 0168
+            #pragma warning disable 0168
             catch (Exception e)
-#pragma warning restore
+            #pragma warning restore
             {
                 return result != null;
             }
         }
-        
-        
+
+
         private static bool TryParseWrapper(NotionProperty property, Type fieldType, out object result)
         {
             result = null;
@@ -167,9 +162,9 @@ private static bool TryParseWrapper(NotionProperty property, Type fieldType, out
 
                 return result != null;
             }
-#pragma warning disable 0168
+            #pragma warning disable 0168
             catch (Exception e)
-#pragma warning restore
+            #pragma warning restore
             {
                 return false;
             }
@@ -190,9 +185,9 @@ private static JSONArray GetPropertyValueAsCollection(NotionProperty property)
                         // Tries to parse as an array normally.
                         return JSON.Parse(property.JsonValue).AsArray;
                     }
-#pragma warning disable 0168
+                    #pragma warning disable 0168
                     catch (Exception e)
-#pragma warning restore
+                    #pragma warning restore
                     {
                         // Bracket the data in the [] so it can be parsed correctly.
                         var builder = new StringBuilder();
@@ -236,17 +231,17 @@ private static JSONArray GetPropertyValueAsCollection(NotionProperty property)
                     }
                 }
             }
-#pragma warning disable 0168
+            #pragma warning disable 0168
             catch (Exception e)
-#pragma warning restore
+            #pragma warning restore
             {
                 // If the value is already bracketed when downloading, just use that.
                 //
                 if (property.JsonValue.Contains("[") && property.JsonValue.Contains("]"))
                 {
                     return JSON.Parse(property.JsonValue).AsArray;
                 }
-                
+
                 //
                 // Bracket the data in the [] so it can be parsed correctly.
                 //
@@ -271,7 +266,6 @@ private static bool TryParseAsArray(NotionProperty property, Type fieldType, out
             try
             {
                 var data = GetPropertyValueAsCollection(property);
-                
                 if (fieldType.GetElementType().IsEnum)
                 {
                     var parsedStringArray = new string[data.Count];
@@ -288,7 +282,7 @@ private static bool TryParseAsArray(NotionProperty property, Type fieldType, out
                 {
                     switch (fieldType.GetElementType()?.Name)
                     {
-                        case { } x when x.Equals("Int"):
+                        case { } x when x.Contains("Int"):
 
                             var parsedIntArray = new int[data.Count];
 
@@ -299,7 +293,7 @@ private static bool TryParseAsArray(NotionProperty property, Type fieldType, out
 
                             result = parsedIntArray;
                             break;
-                        case { } x when x.Equals("Boolean"):
+                        case { } x when x.Contains("Boolean"):
 
                             var parsedBoolArray = new bool[data.Count];
 
@@ -310,7 +304,7 @@ private static bool TryParseAsArray(NotionProperty property, Type fieldType, out
 
                             result = parsedBoolArray;
                             break;
-                        case { } x when x.Equals("Single"):
+                        case { } x when x.Contains("Single"):
 
                             var parsedFloatArray = new float[data.Count];
 
@@ -321,7 +315,7 @@ private static bool TryParseAsArray(NotionProperty property, Type fieldType, out
 
                             result = parsedFloatArray;
                             break;
-                        case { } x when x.Equals("Double"):
+                        case { } x when x.Contains("Double"):
 
                             var parsedDoubleArray = new double[data.Count];
 
@@ -332,7 +326,7 @@ private static bool TryParseAsArray(NotionProperty property, Type fieldType, out
 
                             result = parsedDoubleArray;
                             break;
-                        case { } x when x.Equals("String"):
+                        case { } x when x.Contains("String"):
 
                             var parsedStringArray = new string[data.Count];
 
@@ -350,9 +344,9 @@ private static bool TryParseAsArray(NotionProperty property, Type fieldType, out
 
                 return result != null;
             }
-#pragma warning disable 0168
+            #pragma warning disable 0168
             catch (Exception e)
-#pragma warning restore
+            #pragma warning restore
             {
                 return false;
             }
@@ -367,8 +361,8 @@ private static bool TryParseAsList(NotionProperty property, Type fieldType, out
             {
                 var data = GetPropertyValueAsCollection(property);
                 var typeName = fieldType.GenericTypeArguments.Length > 0
-                    ? fieldType.GenericTypeArguments[0]
-                    : fieldType;
+                ? fieldType.GenericTypeArguments[0]
+                : fieldType;
 
 
                 switch (typeName.Name)
@@ -434,9 +428,9 @@ private static bool TryParseAsList(NotionProperty property, Type fieldType, out
 
                 return result != null;
             }
-#pragma warning disable 0168
+            #pragma warning disable 0168
             catch (Exception e)
-#pragma warning restore
+            #pragma warning restore
             {
                 return false;
             }
@@ -459,15 +453,15 @@ private static bool TryParseEnumOrEnumFlags(NotionProperty property, Type fieldT
                         result = Enum.Parse(fieldType, elements[0].Value.Replace(" ", ""));
                         return result != null;
                     }
-                    
+
                     for (var index = 0; index < elements.Count; index++)
                     {
                         combined += elements[index].Value;
-                        
+
                         if (index == elements.Count - 1) continue;
                         combined += ",";
                     }
-                    
+
                     result = Enum.Parse(fieldType, combined);
                     return result != null;
                 }
@@ -478,27 +472,27 @@ private static bool TryParseEnumOrEnumFlags(NotionProperty property, Type fieldT
                         result = Enum.Parse(fieldType, property.JsonValue.Replace(" ", ""));
                         return result != null;
                     }
-#pragma warning disable 0168
+                    #pragma warning disable 0168
                     catch (Exception e)
-#pragma warning restore
+                    #pragma warning restore
                     {
                         result = fieldType.IsValueType ? Activator.CreateInstance(fieldType) : null;
                         return result != null;
                     }
                 }
             }
-#pragma warning disable 0168
+            #pragma warning disable 0168
             catch (Exception e)
-#pragma warning restore
+            #pragma warning restore
             {
                 return false;
             }
         }
-        
-        
+
+
         private static bool IsGenericList(this Type o)
         {
             return (o.IsGenericType && (o.GetGenericTypeDefinition() == typeof(List<>)));
         }
     }
-}
+}
diff --git a/Carter Games/Notion Database To Unity/Shared Systems/Editor/Asset Info/NdAssetVersionData.cs b/Carter Games/Notion Database To Unity/Shared Systems/Editor/Asset Info/NdAssetVersionData.cs
@@ -37,7 +37,7 @@ public static class NdAssetVersionData
         /// <summary>
         /// The version number of the asset.
         /// </summary>
-        public static string VersionNumber => "0.6.1";
+        public static string VersionNumber => "0.6.2";
         
         
         /// <summary>
@@ -46,6 +46,6 @@ public static class NdAssetVersionData
         /// <remarks>
         /// Asset owner is in the UK, so its Y/M/D format.
         /// </remarks>
-        public static string ReleaseDate => "2025/06/30";
+        public static string ReleaseDate => "2025/08/03";
     }
-}
+}
diff --git a/package.json b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "games.carter.standalone.notiondata",
-  "version": "0.6.1",
+  "version": "0.6.2",
   "displayName": "Notion Data (Standalone)",
   "description": "A system to import Notion databases into a Unity scriptable object for use in Unity projects. This is a standalone version of the system in the Cart library of the same name.",
   "unity": "2020.3",

Original file line number	Diff line number	Diff line change
`@@ -1,17 +1,17 @@`
`1`	`1`	`/*`
`2`	`2`	`* Copyright (c) 2025 Carter Games`
`3`		`- *`
	`3`	`+ *`
`4`	`4`	`* Permission is hereby granted, free of charge, to any person obtaining a copy`
`5`	`5`	`* of this software and associated documentation files (the "Software"), to deal`
`6`	`6`	`* in the Software without restriction, including without limitation the rights`
`7`	`7`	`* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell`
`8`	`8`	`* copies of the Software, and to permit persons to whom the Software is`
`9`	`9`	`* furnished to do so, subject to the following conditions:`
`10`		`- *`
	`10`	`+ *`
`11`	`11`	`* The above copyright notice and this permission notice shall be included in`
`12`	`12`	`* all copies or substantial portions of the Software.`
`13`		`- *`
`14`		`- *`
	`13`	`+ *`
	`14`	`+ *`
`15`	`15`	`* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR`
`16`	`16`	`* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,`
`17`	`17`	`* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE`
`@@ -37,22 +37,18 @@ namespace CarterGames.NotionData`
`37`	`37`	`public static class NotionPropertyValueHandler`
`38`	`38`	`{`
`39`	`39`	`/// <summary>`
`40`		`- /// Gets the value in this property its type if possible.`
	`40`	`+ /// Gets the value in this property its type if possible.`
`41`	`41`	`/// </summary>`
`42`	`42`	`/// <param name="property">The notion property to read from.</param>`
`43`	`43`	`/// <param name="fieldType">The field type to match.</param>`
`44`	`44`	`/// <param name="value">The object value assigned.</param>`
`45`	`45`	`/// <returns>If the parsing was successful.</returns>`
`46`	`46`	`public static bool TryGetValueAs(NotionProperty property, Type fieldType, out object value)`
`47`	`47`	`{`
`48`		`- Debug.Log(fieldType);`
`49`		`- Debug.Log(fieldType.IsArray);`
`50`		`-`
`51`		`-`
`52`	`48`	`if (fieldType.IsArray)`
`53`	`49`	`{`
`54`	`50`	`if (TryParseAsArray(property, fieldType, out value)) return true;`
`55`		`-`
	`51`	`+`
`56`	`52`	`if (fieldType.IsEnum)`
`57`	`53`	`{`
`58`	`54`	`if (TryParseEnumOrEnumFlags(property, fieldType, out value)) return true;`
`@@ -62,40 +58,39 @@ public static bool TryGetValueAs(NotionProperty property, Type fieldType, out ob`
`62`	`58`	`if (fieldType.IsGenericList())`
`63`	`59`	`{`
`64`	`60`	`if (TryParseAsList(property, fieldType, out value)) return true;`
`65`		`-`
	`61`	`+`
`66`	`62`	`if (fieldType.IsEnum)`
`67`	`63`	`{`
`68`	`64`	`if (TryParseEnumOrEnumFlags(property, fieldType, out value)) return true;`
`69`	`65`	`}`
`70`	`66`	`}`
`71`		`-`
`72`		`-`
	`67`	`+`
	`68`	`+`
`73`	`69`	`if (TryParseAsPrimitive(property, fieldType, out value)) return true;`
`74`		`-`
`75`		`-`
	`70`	`+`
	`71`	`+`
`76`	`72`	`if (fieldType.IsEnum)`
`77`	`73`	`{`
`78`	`74`	`if (TryParseEnumOrEnumFlags(property, fieldType, out value)) return true;`
`79`	`75`	`}`
`80`		`-`
`81`		`-`
	`76`	`+`
	`77`	`+`
`82`	`78`	`if (TryParseWrapper(property, fieldType, out value)) return true;`
`83`		`-`
`84`		`- Debug.Log(property.PropertyName);`
`85`		`-`
	`79`	`+`
`86`	`80`	`if (fieldType.IsClass)`
`87`	`81`	`{`
	`82`	`+ Debug.Log(property.JsonValue);`
`88`	`83`	`value = JsonUtility.FromJson(property.JsonValue, fieldType);`
`89`	`84`	`return value != null;`
`90`	`85`	`}`
`91`	`86`
`92`	`87`	`Debug.LogError("Couldn't parse data");`
`93`	`88`	`return false;`
`94`	`89`	`}`
`95`		`-`
`96`		`-`
	`90`	`+`
	`91`	`+`
`97`	`92`	`/// <summary>`
`98`		`- /// Gets the value in this property its type if possible (Only as wrapper).`
	`93`	`+ /// Gets the value in this property its type if possible (Only as wrapper).`
`99`	`94`	`/// </summary>`
`100`	`95`	`/// <param name="property">The notion property to read from.</param>`
`101`	`96`	`/// <param name="fieldType">The field type to match.</param>`
`@@ -104,16 +99,16 @@ public static bool TryGetValueAs(NotionProperty property, Type fieldType, out ob`
`104`	`99`	`public static bool TryGetValueAsWrapper(NotionProperty property, Type fieldType, out object value)`
`105`	`100`	`{`
`106`	`101`	`if (TryParseWrapper(property, fieldType, out value)) return true;`
`107`		`-`
	`102`	`+`
`108`	`103`	`Debug.LogError("Couldn't parse data");`
`109`	`104`	`return false;`
`110`	`105`	`}`
`111`	`106`
`112`		`-`
	`107`	`+`
`113`	`108`	`private static bool TryParseAsPrimitive(NotionProperty property, Type fieldType, out object result)`
`114`	`109`	`{`
`115`	`110`	`result = null;`
`116`		`-`
	`111`	`+`
`117`	`112`	`try`
`118`	`113`	`{`
`119`	`114`	`switch (fieldType.Name)`
`@@ -137,15 +132,15 @@ private static bool TryParseAsPrimitive(NotionProperty property, Type fieldType,`
`137`	`132`
`138`	`133`	`return result != null;`
`139`	`134`	`}`
`140`		`-#pragma warning disable 0168`
	`135`	`+ #pragma warning disable 0168`
`141`	`136`	`catch (Exception e)`
`142`		`-#pragma warning restore`
	`137`	`+ #pragma warning restore`
`143`	`138`	`{`
`144`	`139`	`return result != null;`
`145`	`140`	`}`
`146`	`141`	`}`
`147`		`-`
`148`		`-`
	`142`	`+`
	`143`	`+`
`149`	`144`	`private static bool TryParseWrapper(NotionProperty property, Type fieldType, out object result)`
`150`	`145`	`{`
`151`	`146`	`result = null;`
`@@ -167,9 +162,9 @@ private static bool TryParseWrapper(NotionProperty property, Type fieldType, out`
`167`	`162`
`168`	`163`	`return result != null;`
`169`	`164`	`}`
`170`		`-#pragma warning disable 0168`
	`165`	`+ #pragma warning disable 0168`
`171`	`166`	`catch (Exception e)`
`172`		`-#pragma warning restore`
	`167`	`+ #pragma warning restore`
`173`	`168`	`{`
`174`	`169`	`return false;`
`175`	`170`	`}`
`@@ -190,9 +185,9 @@ private static JSONArray GetPropertyValueAsCollection(NotionProperty property)`
`190`	`185`	`// Tries to parse as an array normally.`
`191`	`186`	`return JSON.Parse(property.JsonValue).AsArray;`
`192`	`187`	`}`
`193`		`-#pragma warning disable 0168`
	`188`	`+ #pragma warning disable 0168`
`194`	`189`	`catch (Exception e)`
`195`		`-#pragma warning restore`
	`190`	`+ #pragma warning restore`
`196`	`191`	`{`
`197`	`192`	`// Bracket the data in the [] so it can be parsed correctly.`
`198`	`193`	`var builder = new StringBuilder();`
`@@ -236,17 +231,17 @@ private static JSONArray GetPropertyValueAsCollection(NotionProperty property)`
`236`	`231`	`}`
`237`	`232`	`}`
`238`	`233`	`}`
`239`		`-#pragma warning disable 0168`
	`234`	`+ #pragma warning disable 0168`
`240`	`235`	`catch (Exception e)`
`241`		`-#pragma warning restore`
	`236`	`+ #pragma warning restore`
`242`	`237`	`{`
`243`	`238`	`// If the value is already bracketed when downloading, just use that.`
`244`	`239`	`//`
`245`	`240`	`if (property.JsonValue.Contains("[") && property.JsonValue.Contains("]"))`
`246`	`241`	`{`
`247`	`242`	`return JSON.Parse(property.JsonValue).AsArray;`
`248`	`243`	`}`
`249`		`-`
	`244`	`+`
`250`	`245`	`//`
`251`	`246`	`// Bracket the data in the [] so it can be parsed correctly.`
`252`	`247`	`//`
`@@ -271,7 +266,6 @@ private static bool TryParseAsArray(NotionProperty property, Type fieldType, out`
`271`	`266`	`try`
`272`	`267`	`{`
`273`	`268`	`var data = GetPropertyValueAsCollection(property);`
`274`		`-`
`275`	`269`	`if (fieldType.GetElementType().IsEnum)`
`276`	`270`	`{`
`277`	`271`	`var parsedStringArray = new string[data.Count];`
`@@ -288,7 +282,7 @@ private static bool TryParseAsArray(NotionProperty property, Type fieldType, out`
`288`	`282`	`{`
`289`	`283`	`switch (fieldType.GetElementType()?.Name)`
`290`	`284`	`{`
`291`		`- case { } x when x.Equals("Int"):`
	`285`	`+ case { } x when x.Contains("Int"):`
`292`	`286`
`293`	`287`	`var parsedIntArray = new int[data.Count];`
`294`	`288`
`@@ -299,7 +293,7 @@ private static bool TryParseAsArray(NotionProperty property, Type fieldType, out`
`299`	`293`
`300`	`294`	`result = parsedIntArray;`
`301`	`295`	`break;`
`302`		`- case { } x when x.Equals("Boolean"):`
	`296`	`+ case { } x when x.Contains("Boolean"):`
`303`	`297`
`304`	`298`	`var parsedBoolArray = new bool[data.Count];`
`305`	`299`
`@@ -310,7 +304,7 @@ private static bool TryParseAsArray(NotionProperty property, Type fieldType, out`
`310`	`304`
`311`	`305`	`result = parsedBoolArray;`
`312`	`306`	`break;`
`313`		`- case { } x when x.Equals("Single"):`
	`307`	`+ case { } x when x.Contains("Single"):`
`314`	`308`
`315`	`309`	`var parsedFloatArray = new float[data.Count];`
`316`	`310`
`@@ -321,7 +315,7 @@ private static bool TryParseAsArray(NotionProperty property, Type fieldType, out`
`321`	`315`
`322`	`316`	`result = parsedFloatArray;`
`323`	`317`	`break;`
`324`		`- case { } x when x.Equals("Double"):`
	`318`	`+ case { } x when x.Contains("Double"):`
`325`	`319`
`326`	`320`	`var parsedDoubleArray = new double[data.Count];`
`327`	`321`
`@@ -332,7 +326,7 @@ private static bool TryParseAsArray(NotionProperty property, Type fieldType, out`
`332`	`326`
`333`	`327`	`result = parsedDoubleArray;`
`334`	`328`	`break;`
`335`		`- case { } x when x.Equals("String"):`
	`329`	`+ case { } x when x.Contains("String"):`
`336`	`330`
`337`	`331`	`var parsedStringArray = new string[data.Count];`
`338`	`332`
`@@ -350,9 +344,9 @@ private static bool TryParseAsArray(NotionProperty property, Type fieldType, out`
`350`	`344`
`351`	`345`	`return result != null;`
`352`	`346`	`}`
`353`		`-#pragma warning disable 0168`
	`347`	`+ #pragma warning disable 0168`
`354`	`348`	`catch (Exception e)`
`355`		`-#pragma warning restore`
	`349`	`+ #pragma warning restore`
`356`	`350`	`{`
`357`	`351`	`return false;`
`358`	`352`	`}`
`@@ -367,8 +361,8 @@ private static bool TryParseAsList(NotionProperty property, Type fieldType, out`
`367`	`361`	`{`
`368`	`362`	`var data = GetPropertyValueAsCollection(property);`
`369`	`363`	`var typeName = fieldType.GenericTypeArguments.Length > 0`
`370`		`- ? fieldType.GenericTypeArguments[0]`
`371`		`- : fieldType;`
	`364`	`+ ? fieldType.GenericTypeArguments[0]`
	`365`	`+ : fieldType;`
`372`	`366`
`373`	`367`
`374`	`368`	`switch (typeName.Name)`
`@@ -434,9 +428,9 @@ private static bool TryParseAsList(NotionProperty property, Type fieldType, out`
`434`	`428`
`435`	`429`	`return result != null;`
`436`	`430`	`}`
`437`		`-#pragma warning disable 0168`
	`431`	`+ #pragma warning disable 0168`
`438`	`432`	`catch (Exception e)`
`439`		`-#pragma warning restore`
	`433`	`+ #pragma warning restore`
`440`	`434`	`{`
`441`	`435`	`return false;`
`442`	`436`	`}`
`@@ -459,15 +453,15 @@ private static bool TryParseEnumOrEnumFlags(NotionProperty property, Type fieldT`
`459`	`453`	`result = Enum.Parse(fieldType, elements[0].Value.Replace(" ", ""));`
`460`	`454`	`return result != null;`
`461`	`455`	`}`
`462`		`-`
	`456`	`+`
`463`	`457`	`for (var index = 0; index < elements.Count; index++)`
`464`	`458`	`{`
`465`	`459`	`combined += elements[index].Value;`
`466`		`-`
	`460`	`+`
`467`	`461`	`if (index == elements.Count - 1) continue;`
`468`	`462`	`combined += ",";`
`469`	`463`	`}`
`470`		`-`
	`464`	`+`
`471`	`465`	`result = Enum.Parse(fieldType, combined);`
`472`	`466`	`return result != null;`
`473`	`467`	`}`
`@@ -478,27 +472,27 @@ private static bool TryParseEnumOrEnumFlags(NotionProperty property, Type fieldT`
`478`	`472`	`result = Enum.Parse(fieldType, property.JsonValue.Replace(" ", ""));`
`479`	`473`	`return result != null;`
`480`	`474`	`}`
`481`		`-#pragma warning disable 0168`
	`475`	`+ #pragma warning disable 0168`
`482`	`476`	`catch (Exception e)`
`483`		`-#pragma warning restore`
	`477`	`+ #pragma warning restore`
`484`	`478`	`{`
`485`	`479`	`result = fieldType.IsValueType ? Activator.CreateInstance(fieldType) : null;`
`486`	`480`	`return result != null;`
`487`	`481`	`}`
`488`	`482`	`}`
`489`	`483`	`}`
`490`		`-#pragma warning disable 0168`
	`484`	`+ #pragma warning disable 0168`
`491`	`485`	`catch (Exception e)`
`492`		`-#pragma warning restore`
	`486`	`+ #pragma warning restore`
`493`	`487`	`{`
`494`	`488`	`return false;`
`495`	`489`	`}`
`496`	`490`	`}`
`497`		`-`
`498`		`-`
	`491`	`+`
	`492`	`+`
`499`	`493`	`private static bool IsGenericList(this Type o)`
`500`	`494`	`{`
`501`	`495`	`return (o.IsGenericType && (o.GetGenericTypeDefinition() == typeof(List<>)));`
`502`	`496`	`}`
`503`	`497`	`}`
`504`		`-}`
	`498`	`+}`
Original file line number	Diff line number	Diff line change
`@@ -1,6 +1,6 @@`
`1`	`1`	`{`
`2`	`2`	`"name": "games.carter.standalone.notiondata",`
`3`		`- "version": "0.6.1",`
	`3`	`+ "version": "0.6.2",`
`4`	`4`	`"displayName": "Notion Data (Standalone)",`
`5`	`5`	`"description": "A system to import Notion databases into a Unity scriptable object for use in Unity projects. This is a standalone version of the system in the Cart library of the same name.",`
`6`	`6`	`"unity": "2020.3",`