@nativescript/windows 0.1.0-alpha.57 → 0.1.0-alpha.59

package/framework/dotnet-bridge/Bridge.BinaryDispatch.cs

@@ -65,6 +65,14 @@ public static partial class Bridge
             var type   = target?.GetType() ?? throw new InvalidOperationException("Handle is null");
             var method = r.ReadString16();
             var args   = r.ReadArgs();
+
+            if (method == "__dotnet_await__" && args.Length == 2
+                && args[0] is int resolveId && args[1] is int rejectId)
+            {
+                ScheduleTaskContinuation(handle, resolveId, rejectId);
+                return DispatchResult.Void;
+            }
+
             return DispatchCallBin(target, type, method, args, isStatic: false);
         }
 

package/framework/dotnet-bridge/Bridge.Dispatch.cs

@@ -42,6 +42,18 @@ public static partial class Bridge
         if (method == "__members__")
             return BuildMembersResult(type);
 
+        if (method == "__dotnet_await__" && req.Handle.HasValue)
+        {
+            var a = req.Args ?? [];
+            if (a.Length >= 2)
+            {
+                var resolveId = (int)a[0].GetInt64();
+                var rejectId  = (int)a[1].GetInt64();
+                ScheduleTaskContinuation(req.Handle.Value, resolveId, rejectId);
+            }
+            return DispatchResult.Void;
+        }
+
         if (method == ".ctor")
         {
             var argElems = req.Args ?? [];
@@ -228,7 +240,21 @@ public static partial class Bridge
 
         var id = Interlocked.Increment(ref s_nextHandle);
         s_handles[id] = value;
-        return DispatchResult.Handle(id, t.FullName ?? t.Name);
+        var typeName = t.FullName ?? t.Name;
+        return IsAwaitable(value, t)
+            ? DispatchResult.TaskHandle(id, typeName)
+            : DispatchResult.Handle(id, typeName);
+    }
+
+    private static bool IsAwaitable(object value, Type t)
+    {
+        if (value is Task || value is ValueTask) return true;
+        if (t.IsGenericType && t.GetGenericTypeDefinition() == typeof(ValueTask<>)) return true;
+        var fn = t.FullName ?? "";
+        if (fn.StartsWith("Windows.Foundation.IAsync", StringComparison.Ordinal)) return true;
+        return t.GetMethod("GetAwaiter",
+                   BindingFlags.Public | BindingFlags.Instance,
+                   null, Type.EmptyTypes, null) is not null;
     }
 
     internal static DispatchResult BuildMembersResult(Type t)

package/framework/dotnet-bridge/Bridge.TaskHelper.cs

@@ -0,0 +1,121 @@
+using System;
+using System.Collections.Concurrent;
+using System.Collections.Generic;
+using System.Reflection;
+using System.Threading.Tasks;
+
+namespace NativeScriptBridge;
+
+public static partial class Bridge
+{
+    private static readonly ConcurrentDictionary<Type, Func<object, Task>?> s_awaitableCache = new();
+
+    // Invoked when the binary instance call "__dotnet_await__(resolveId, rejectId)" arrives.
+    // Converts any awaitable handle (Task<T>, ValueTask<T>, IAsyncOperation<T>, …) into an
+    // async continuation that calls back into V8 via s_jsInvoker when it completes —
+    // without blocking the main thread.
+    internal static void ScheduleTaskContinuation(int handleId, int resolveId, int rejectId)
+    {
+        if (!s_handles.TryGetValue(handleId, out var obj) || obj is null)
+            throw new KeyNotFoundException($"Invalid handle {handleId}");
+
+        var task = GetTaskForAwaitable(obj)
+            ?? throw new InvalidOperationException(
+                $"Object of type {obj.GetType().FullName} is not awaitable. " +
+                $"Expected Task<T>, ValueTask<T>, or any type implementing GetAwaiter().");
+
+        task.ContinueWith(completed =>
+        {
+            s_handles.TryRemove(handleId, out _);
+            try
+            {
+                if (completed.IsFaulted)
+                {
+                    var ex = completed.Exception?.InnerException ?? completed.Exception;
+                    CallJsCallback(rejectId, [ex?.Message ?? "Task faulted"]);
+                }
+                else if (completed.IsCanceled)
+                {
+                    CallJsCallback(rejectId, ["Task cancelled"]);
+                }
+                else
+                {
+                    CallJsCallback(resolveId, [TaskResultCache.GetResult(completed)]);
+                }
+            }
+            catch (Exception ex)
+            {
+                CallJsCallback(rejectId, [ex.Message]);
+            }
+        }, TaskScheduler.Default);
+    }
+
+    // Converts any awaitable to a Task<object?> using the GetAwaiter() pattern via
+    // reflection. Handles Task<T>, ValueTask<T>, WinRT IAsyncOperation<T>, and any
+    // custom awaitable without requiring compile-time type knowledge. Results are
+    // cached per awaitable type so reflection only runs on the first encounter.
+    private static Task? GetTaskForAwaitable(object obj)
+    {
+        if (obj is Task t) return t;
+        if (obj is ValueTask vt) return vt.AsTask();
+
+        var type = obj.GetType();
+        if (type.IsGenericType && type.GetGenericTypeDefinition() == typeof(ValueTask<>))
+            return ValueTaskAsTaskCache.AsTask(type, obj);
+
+        return s_awaitableCache.GetOrAdd(type, BuildAwaitableFactory)?.Invoke(obj);
+    }
+
+    // Builds a factory that wraps an arbitrary awaitable type in a
+    // TaskCompletionSource<object?>.  Works for any type with GetAwaiter() returning
+    // an object that has IsCompleted, GetResult(), and OnCompleted/UnsafeOnCompleted.
+    private static Func<object, Task>? BuildAwaitableFactory(Type type)
+    {
+        var getAwaiter = type.GetMethod("GetAwaiter",
+            BindingFlags.Instance | BindingFlags.Public, null, Type.EmptyTypes, null);
+        if (getAwaiter is null) return null;
+
+        var awaiterType = getAwaiter.ReturnType;
+        var isCompleted = awaiterType.GetProperty("IsCompleted");
+        var getResult   = awaiterType.GetMethod("GetResult",
+            BindingFlags.Instance | BindingFlags.Public, null, Type.EmptyTypes, null);
+        var onCompleted = awaiterType.GetMethod("UnsafeOnCompleted",
+                              BindingFlags.Instance | BindingFlags.Public)
+                       ?? awaiterType.GetMethod("OnCompleted",
+                              BindingFlags.Instance | BindingFlags.Public);
+
+        if (isCompleted is null || onCompleted is null) return null;
+
+        return obj =>
+        {
+            var tcs = new TaskCompletionSource<object?>(
+                TaskCreationOptions.RunContinuationsAsynchronously);
+            try
+            {
+                var awaiter = getAwaiter.Invoke(obj, null);
+                if (awaiter is null) { tcs.SetResult(null); return tcs.Task; }
+
+                void Complete()
+                {
+                    try
+                    {
+                        tcs.SetResult(getResult?.Invoke(awaiter, null));
+                    }
+                    catch (System.Reflection.TargetInvocationException ex)
+                    {
+                        tcs.SetException(ex.InnerException ?? ex);
+                    }
+                    catch (Exception ex) { tcs.SetException(ex); }
+                }
+
+                if ((bool)(isCompleted.GetValue(awaiter) ?? false))
+                    Complete();
+                else
+                    onCompleted.Invoke(awaiter, [(Action)Complete]);
+            }
+            catch (Exception ex) { tcs.SetException(ex); }
+
+            return tcs.Task;
+        };
+    }
+}

package/framework/dotnet-bridge/DispatchTypes.cs

@@ -46,7 +46,7 @@ internal readonly struct CtorEntry(ConstructorInfo? ctor, ParameterInfo[] parame
     public readonly ParameterInfo[]  Parameters = parameters;
 }
 
-internal enum DispatchKind : byte { Void, Primitive, Handle, Collection, Members }
+internal enum DispatchKind : byte { Void, Primitive, Handle, Collection, Members, TaskHandle }
 
 internal readonly struct DispatchResult
 {
@@ -86,6 +86,9 @@ internal readonly struct DispatchResult
     public static DispatchResult Handle(int id, string typeName)
         => new(DispatchKind.Handle, null, null, id, typeName, null, null, null, null);
 
+    public static DispatchResult TaskHandle(int id, string typeName)
+        => new(DispatchKind.TaskHandle, null, null, id, typeName, null, null, null, null);
+
     public static DispatchResult Collection(IEnumerable items)
         => new(DispatchKind.Collection, items, null, 0, null, null, null, null, null);
 
@@ -118,6 +121,14 @@ internal readonly struct DispatchResult
                 w.WriteEndObject();
                 break;
 
+            case DispatchKind.TaskHandle:
+                w.WriteStartObject();
+                w.WriteNumber("__handle"u8, _handle);
+                w.WriteString("__type"u8,   _typeName);
+                w.WriteBoolean("__isTask"u8, true);
+                w.WriteEndObject();
+                break;
+
             case DispatchKind.Collection:
                 w.WriteStartArray();
                 foreach (var item in (IEnumerable)_value!)
@@ -175,6 +186,12 @@ internal readonly struct DispatchResult
                 w.WriteString16(_typeName ?? "");
                 break;
 
+            case DispatchKind.TaskHandle:
+                w.WriteByte(0x0C);
+                w.WriteI32(_handle);
+                w.WriteString16(_typeName ?? "");
+                break;
+
             case DispatchKind.Collection:
                 var items = new List<object?>();
                 foreach (var item in (IEnumerable)_value!) items.Add(item);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nativescript/windows",
-  "version": "0.1.0-alpha.57",
+  "version": "0.1.0-alpha.59",
   "description": "NativeScript for using Windows v8",
   "repository": {
         "type": "git",