Merge pull request #9 from coryleach/dev

Minor Bump for WebGL Compatibility Changes

README.md

@@ -19,15 +19,15 @@
 #### Using UnityPackageManager (for Unity 2019.3 or later)
 Open the package manager window (menu: Window > Package Manager)<br/>
 Select "Add package from git URL...", fill in the pop-up with the following link:<br/>
-https://github.com/coryleach/UnityAsync.git#1.0.5<br/>
+https://github.com/coryleach/UnityAsync.git#1.0.6<br/>
 
 #### Using UnityPackageManager (for Unity 2019.1 or later)
 
 Find the manifest.json file in the Packages folder of your project and edit it to look like this:
 ```js
 {
   "dependencies": {
-    "com.gameframe.async": "https://github.com/coryleach/UnityAsync.git#1.0.5",
+    "com.gameframe.async": "https://github.com/coryleach/UnityAsync.git#1.0.6",
     ...
   },
 }
@@ -93,7 +93,7 @@ await Awaiters.MainUnityThread;
 
 ## Show your support
 Give a ⭐️ if this project helped you!
-{AUTHOR.KOFI}
+
 
 ***
 _This README was generated with ❤️ by [Gameframe.Packages](https://github.com/coryleach/unitypackages)_

Runtime/Coroutines/CoroutineRunner.cs

@@ -23,24 +23,24 @@ private static void Install()
             UnitySynchronizationContext = SynchronizationContext.Current;
             Application.quitting += OnApplicationQuitting;
         }
-        
+
 #if UNITY_EDITOR
         [InitializeOnLoadMethod]
         private static void EditorInstall()
         {
-            EditorApplication.playModeStateChanged += EditorApplicationOnPlayModeStateChanged;   
+            EditorApplication.playModeStateChanged += EditorApplicationOnPlayModeStateChanged;
         }
 
         private static void EditorApplicationOnPlayModeStateChanged(PlayModeStateChange obj)
         {
             //I do not intend to support editor coroutines
             //Do I need to cancel coroutines on play mode change?
         }
-#endif   
-        
+#endif
+
         private static SynchronizationContext UnitySynchronizationContext { get; set; }
         private static CancellationTokenSource cancellationTokenSource = new CancellationTokenSource();
-        
+
         /// <summary>
         /// Use this method when you want to await coroutine completion.
         /// Coroutine itself will always run on the main thread.
@@ -49,19 +49,19 @@ private static void EditorApplicationOnPlayModeStateChanged(PlayModeStateChange
         /// <returns>awaitable task</returns>
         public static async Task RunAsync(IEnumerator routine)
         {
-            await UnityTaskUtil.RunOnUnityThreadAsync(async () => await RunAsync(routine,cancellationTokenSource.Token).ConfigureAwait(false) );
+            await UnityTaskUtil.RunOnUnityThreadAsync(async () => await RunAsync(routine,cancellationTokenSource.Token));
         }
-        
+
         /// <summary>
         /// Use this method to start a coroutine from any thread.
         /// Coroutines themselves always run on the main thread
         /// </summary>
         /// <param name="enumerator">coroutine to run</param>
         public static void Start(IEnumerator enumerator)
         {
-            UnityTaskUtil.RunOnUnityThread(async () => await RunAsync(enumerator,cancellationTokenSource.Token).ConfigureAwait(false));
+            UnityTaskUtil.RunOnUnityThread(async () => await RunAsync(enumerator,cancellationTokenSource.Token));
         }
-    
+
         /// <summary>
         /// Stop all coroutines that have been started with CoroutineRunner
         /// </summary>
@@ -70,12 +70,12 @@ public static void StopAll()
             cancellationTokenSource.Cancel();
             cancellationTokenSource = new CancellationTokenSource();
         }
-        
+
         private static void OnApplicationQuitting()
         {
             StopAll();
         }
-    
+
         private static async Task RunAsync(IEnumerator routine, CancellationToken token)
         {
             var coroutine = RunCoroutine(routine);
@@ -85,17 +85,17 @@ private static async Task RunAsync(IEnumerator routine, CancellationToken token)
                 await Task.Yield();
             }
         }
-        
+
         private static IEnumerator RunCoroutine(object state)
         {
             var processStack = new Stack<IEnumerator>();
             processStack.Push((IEnumerator)state);
-    
+
             while (processStack.Count > 0)
             {
                 var currentCoroutine = processStack.Peek();
                 var done = false;
-    
+
                 try
                 {
                     done = !currentCoroutine.MoveNext();
@@ -105,7 +105,7 @@ private static IEnumerator RunCoroutine(object state)
                     Debug.LogException(e);
                     yield break;
                 }
-    
+
                 if (done)
                 {
                     processStack.Pop();
@@ -121,10 +121,9 @@ private static IEnumerator RunCoroutine(object state)
                         yield return currentCoroutine.Current;
                     }
                 }
-                    
+
             }
         }
-        
+
     }
 }
-

Runtime/UnityTaskUtil.cs

@@ -20,7 +20,7 @@ private static void Install()
         }
 
         public static bool CurrentThreadIsUnityThread => UnityThreadId == Thread.CurrentThread.ManagedThreadId;
-        
+
         public static TaskScheduler UnityTaskScheduler { get; private set; }
 
         public static TaskFactory<UnityEngine.Object> UnityTaskFactory { get; private set; }
@@ -42,7 +42,7 @@ public static CoroutineWrapper StartCancelableCoroutineAsync(IEnumerator corouti
             RunOnUnityScheduler(() => { host.StartCoroutine(wrapper.Run(coroutine)); });
             return wrapper;
         }
-        
+
         /// <summary>
         /// Invokes an action on the Unity main thread.
         /// Will invoke immediately if already on the main thread.
@@ -75,10 +75,10 @@ public static async Task<T> RunOnUnityThreadAsync<T>(Func<T> func)
             }
             var taskFactory = new TaskFactory<T>(UnityTaskScheduler);
             var task = taskFactory.StartNew(func);
-            await task.ConfigureAwait(false);
+            await task;
             return task.Result;
         }
-        
+
         /// <summary>
         /// Runs the given action on the Unity main thread
         /// Will invoke immediately if already on the main thread
@@ -94,7 +94,7 @@ public static async Task RunOnUnityThreadAsync(Action action)
             }
             var taskFactory = new TaskFactory(UnityTaskScheduler);
             var task = taskFactory.StartNew(action);
-            await task.ConfigureAwait(false);
+            await task;
         }
 
         /// <summary>
@@ -113,7 +113,7 @@ public static void RunOnUnityThread(Action action)
                 UnitySynchronizationContext.Post(_=> action(), null);
             }
         }
-        
+
         /// <summary>
         /// Runs the given async delegate on the Unity main thread
         /// </summary>
@@ -151,10 +151,10 @@ public static async Task<T> InstantiateAsync<T>(T prefab, Transform parent) wher
                 instance.name = prefab.name;
                 return instance;
             });
-            await task.ConfigureAwait(false);
+            await task;
             return task.Result as T;
         }
-        
+
         /// <summary>
         /// Instantiate a prefab asynchronously
         /// Always creates a task on the Unity task scheduler even if already on the main thread.
@@ -170,9 +170,9 @@ public static async Task<T> InstantiateAsync<T>(T prefab) where T : UnityEngine.
                 instance.name = prefab.name;
                 return instance;
             });
-            await task.ConfigureAwait(false);
+            await task;
             return task.Result as T;
         }
 
     }
-}
+}

package.json

@@ -1,7 +1,7 @@
 {
   "name": "com.gameframe.async",
   "displayName": "Gameframe.Async",
-  "version": "1.0.5",
+  "version": "1.0.6",
   "description": "> Async task utility package for Unity  \n> Helper methods for starting tasks on the Unity thread.  \n> Start and await coroutines from any thread.",
   "keywords": [],
   "author": {