Add Options.Constraints.PromiseTimeout To Control timeout for DisposeHint.Async and JintAwaitExpression

Jint.Tests/Runtime/AsyncTests.cs

@@ -41,6 +41,29 @@ public void ShouldReturnedTaskConvertedToPromiseInJS()
         result = result.UnwrapIfPromise();
         Assert.Equal(AsyncTestClass.TestString, result);
     }
+    [Fact]
+    public void ShouldUnwrapPromiseWithCustomTimeout()
+    {
+        Engine engine = new(options => options.ExperimentalFeatures = ExperimentalFeature.TaskInterop);
+        engine.SetValue("asyncTestClass", new AsyncTestClass());
+        var result = engine.Evaluate("asyncTestClass.ReturnDelayedTaskAsync().then(x=>x)");
+        result = result.UnwrapIfPromise(TimeSpan.FromMilliseconds(200));
+        Assert.Equal(AsyncTestClass.TestString, result);
+    }
+
+    [Fact]
+    public void ShouldAwaitUnwrapPromiseWithCustomTimeout()
+    {
+        Engine engine = new(options => { options.ExperimentalFeatures = ExperimentalFeature.TaskInterop; options.Constraints.UnwrapIfPromiseTimeout = TimeSpan.FromMilliseconds(500); });
+        engine.SetValue("asyncTestClass", new AsyncTestClass());
+        engine.Execute(""" 
+        async function test() {
+            return await asyncTestClass.ReturnDelayedTaskAsync();
+        }
+        """);
+        var result = engine.Invoke("test").UnwrapIfPromise();
+        Assert.Equal(AsyncTestClass.TestString, result);
+    }
 
     [Fact]
     public void ShouldReturnedCompletedTaskConvertedToPromiseInJS()
@@ -230,7 +253,7 @@ async function foo(name) {
 
         Assert.Equal(expected, log.Select(x => x.AsString()).ToArray());
     }
-    
+
     [Fact]
     public void ShouldPromiseBeResolved()
     {
@@ -240,7 +263,7 @@ public void ShouldPromiseBeResolved()
         {
             log.Add(str);
         });
-        
+
         const string Script = """
           async function main() {
             return new Promise(function (resolve) {
@@ -268,7 +291,7 @@ public void ShouldPromiseBeResolved2()
             {
                 Task.Delay(ms).ContinueWith(_ => action());
             });
-        
+
         const string Script = """
           var delay = (ms) => new Promise(resolve => setTimeout(resolve, ms));
           async function main() {

Jint/Native/Disposable/DisposeCapability.cs

@@ -87,7 +87,7 @@ public Completion DisposeResources(Completion c)
                         hasAwaited = true;
                         try
                         {
-                            result = result.UnwrapIfPromise();
+                            result = result.UnwrapIfPromise(_engine.Options.Constraints.UnwrapIfPromiseTimeout);
                         }
                         catch (JavaScriptException e)
                         {

Jint/Options.cs

@@ -431,6 +431,12 @@ public class ConstraintOptions
         /// </summary>
         public TimeSpan RegexTimeout { get; set; } = TimeSpan.FromSeconds(10);
 
+
+        /// <summary>
+        /// Maximum time allowed for unwrapping a Promise and getting its resolved/rejected value.
+        /// Defaults to 10 seconds.
+        /// </summary>
+        public TimeSpan UnwrapIfPromiseTimeout { get; set; } = TimeSpan.FromSeconds(10);
         /// <summary>
         /// The maximum size for JavaScript array, defaults to <see cref="uint.MaxValue"/>.
         /// </summary>

Jint/Runtime/Interpreter/Expressions/JintAwaitExpression.cs

@@ -34,7 +34,7 @@ protected override object EvaluateInternal(EvaluationContext context)
                 value = promiseInstance;
             }
 
-            return value.UnwrapIfPromise();
+            return value.UnwrapIfPromise(engine.Options.Constraints.UnwrapIfPromiseTimeout);
         }
         catch (PromiseRejectedException e)
         {