react-native-windows 0.70.8 → 0.71.0-preview.1

package/Microsoft.ReactNative.Managed/ReactPromise.cs

@@ -16,102 +16,144 @@ using System.Collections.Generic;
 
 namespace Microsoft.ReactNative.Managed
 {
-    // Implementation of IReactPromise that represents a JavaScript Promise
-    // which can be passed to the native module as a method parameter.
-    //
-    // Methods with ReactMethodAttribute that use an IReactPromise as the last parameter
-    // will be marked as "promise" and will return a promise when invoked from JavaScript.
-    public class ReactPromise<T> : IReactPromise<T>
+  // Implementation of IReactPromise that represents a JavaScript Promise
+  // which can be passed to the native module as a method parameter.
+  //
+  // Methods with ReactMethodAttribute that use an IReactPromise as the last parameter
+  // will be marked as "promise" and will return a promise when invoked from JavaScript.
+  public class ReactPromise<T> : IReactPromise<T>
+  {
+    private IJSValueWriter m_writer;
+    private MethodResultCallback m_resolve;
+    private MethodResultCallback m_reject;
+    private object m_mutex = new object();
+
+    public ReactPromise(IJSValueWriter writer, MethodResultCallback resolve, MethodResultCallback reject)
+    {
+      m_writer = writer;
+      m_resolve = resolve;
+      m_reject = reject;
+    }
+
+    //  Successfully resolve the ReactPromise with an optional value.
+    public void Resolve(T value)
     {
-        private IJSValueWriter m_writer;
-        private MethodResultCallback m_resolve;
-        private MethodResultCallback m_reject;
+      // Copy to local variables to run resolve outside of lock
+      MethodResultCallback resolve = null;
+      IJSValueWriter writer = null;
 
-        public ReactPromise(IJSValueWriter writer, MethodResultCallback resolve, MethodResultCallback reject)
+      lock (m_mutex)
+      {
+        if (m_resolve != null)
         {
-            m_writer = writer;
-            m_resolve = resolve;
-            m_reject = reject;
+          resolve = m_resolve;
+          writer = m_writer;
         }
 
-        //  Successfully resolve the ReactPromise with an optional value.
-        public void Resolve(T value)
-        {
-            if (m_resolve != null)
-            {
-                m_writer.WriteArgs(value);
-                m_resolve(m_writer);
-            }
+        Clear();
+      }
 
-            Clear();
-        }
+      if (resolve != null)
+      {
+        writer.WriteArgs(value);
+        resolve(writer);
+      }
+    }
 
-        // Reject the ReactPromise and report an error.
-        public void Reject(ReactError error)
-        {
-            if (m_reject != null)
-            {
-                ReactPromiseWriter.WriteError(m_writer,
-                  code: error?.Code,
-                  message: error?.Message,
-                  userInfo: error?.UserInfo,
-                  stackTrace: error?.Exception?.StackTrace);
-                m_reject(m_writer);
-            }
-
-            Clear();
-        }
+    // Reject the ReactPromise and report an error.
+    public void Reject(ReactError error)
+    {
+      // Copy to local variables to run reject outside of lock
+      MethodResultCallback reject = null;
+      IJSValueWriter writer = null;
 
-        private void Clear()
+      lock (m_mutex)
+      {
+        if (m_reject != null)
         {
-            m_resolve = null;
-            m_reject = null;
-            m_writer = null;
+          reject = m_reject;
+          writer = m_writer;
         }
+
+        Clear();
+      }
+
+      if (reject != null)
+      {
+        ReactPromiseWriter.WriteError(writer,
+          code: error.Code,
+          message: error.Message,
+          userInfo: error.UserInfo,
+          stackTrace: error.Exception?.StackTrace);
+        reject(writer);
+      }
     }
 
-    public static class ReactPromiseWriter
+    public void Reject(string errorMessage)
     {
-        public static void WriteError(
-          IJSValueWriter writer,
-          string code,
-          string message,
-          IReadOnlyDictionary<string, JSValue> userInfo,
-          string stackTrace)
+      Reject(new ReactError(errorMessage));
+    }
+
+    private void Clear()
+    {
+      m_resolve = null;
+      m_reject = null;
+      m_writer = null;
+    }
+  }
+
+  public static class ReactPromiseWriter
+  {
+    public static void WriteError(
+      IJSValueWriter writer,
+      string code,
+      string message,
+      IReadOnlyDictionary<string, JSValue> userInfo,
+      string stackTrace)
+    {
+      writer.WriteArrayBegin();
+      {
+        writer.WriteObjectBegin();
         {
-            writer.WriteArrayBegin();
-            {
-                writer.WriteObjectBegin();
-                {
-                    writer.WritePropertyName(ReactErrorConstants.Code);
-                    writer.WriteString(code ?? ReactErrorConstants.DefaultCode);
-
-                    writer.WritePropertyName(ReactErrorConstants.Message);
-                    writer.WriteString(message ?? ReactErrorConstants.DefaultMessage);
-
-                    // For consistency with iOS ensure userInfo key exists, even if we null it.
-                    // iOS: /React/Base/RCTUtils.m -> RCTJSErrorFromCodeMessageAndNSError
-                    writer.WritePropertyName(ReactErrorConstants.UserInfo);
-                    if (userInfo == null)
-                    {
-                        writer.WriteNull();
-                    }
-                    else
-                    {
-                        writer.WriteValue(userInfo);
-                    }
-
-                    // Attach a nativeStackWindows string if an exception was passed.
-                    // This matches iOS behavior - iOS adds a `nativeStackIOS` property
-                    // iOS: /React/Base/RCTUtils.m -> RCTJSErrorFromCodeMessageAndNSError
-                    writer.WritePropertyName(ReactErrorConstants.NativeStack);
-                    writer.WriteString(stackTrace ?? string.Empty);
-                }
-                writer.WriteObjectEnd();
-
-            }
-            writer.WriteArrayEnd();
+          writer.WritePropertyName(ReactError.CodeKey);
+          writer.WriteString(code ?? ReactError.DefaultCode);
+
+          writer.WritePropertyName(ReactError.MessageKey);
+          writer.WriteString(message ?? ReactError.DefaultMessage);
+
+          // For consistency with iOS ensure userInfo key exists, even if we null it.
+          // iOS: /React/Base/RCTUtils.m -> RCTJSErrorFromCodeMessageAndNSError
+          writer.WritePropertyName(ReactError.UserInfoKey);
+          if (userInfo == null)
+          {
+            writer.WriteNull();
+          }
+          else
+          {
+            writer.WriteValue(userInfo);
+          }
+
+          // Attach a nativeStackWindows string if an exception was passed.
+          // This matches iOS behavior - iOS adds a `nativeStackIOS` property
+          // iOS: /React/Base/RCTUtils.m -> RCTJSErrorFromCodeMessageAndNSError
+          writer.WritePropertyName(ReactError.NativeStackKey);
+          writer.WriteString(stackTrace ?? string.Empty);
         }
+        writer.WriteObjectEnd();
+
+      }
+      writer.WriteArrayEnd();
+    }
+  }
+
+  public class ReactPromise : ReactPromise<JSValue>
+  {
+    public ReactPromise(IJSValueWriter writer, MethodResultCallback resolve, MethodResultCallback reject)
+      : base(writer, resolve, reject) { }
 
+    public void Resolve()
+    {
+      Resolve(JSValue.Null);
     }
+  }
 }

package/Microsoft.ReactNative.Managed/ReactPropertyBag.cs

@@ -0,0 +1,91 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+using System;
+
+namespace Microsoft.ReactNative.Managed
+{
+  public struct ReactPropertyBag
+  {
+    public IReactPropertyBag Handle { get; }
+
+    public bool IsValid => Handle != null;
+
+    public static explicit operator bool(ReactPropertyBag propertyBag) => propertyBag.IsValid;
+
+    public ReactPropertyBag(IReactPropertyBag handle = null)
+    {
+      Handle = handle;
+    }
+
+    // Get property value by property name.
+    public static T Get<T>(IReactPropertyBag handle, ReactPropertyId<T> propertyId)
+    {
+      if (handle == null)
+      {
+        return default(T);
+      }
+      object propertyValue = handle.Get(propertyId.Handle);
+      return (T)propertyValue;
+    }
+
+    // Ensure that property is created by calling valueCreator if needed,
+    // and return value by property name. The TCreateValue must return
+    // either T or std::optional<T>. It must have no parameters.
+    public static T GetOrCreate<T>(IReactPropertyBag handle,
+      ReactPropertyId<T> propertyId,
+      Func<T> createValue)
+    {
+      if (handle == null)
+      {
+        return default(T);
+      }
+      object propertyValue = handle.GetOrCreate(propertyId.Handle, () => createValue());
+      return (T)propertyValue;
+    }
+
+    // Set property value by property name.
+    public static void Set<T>(IReactPropertyBag handle, ReactPropertyId<T> propertyId, T value)
+    {
+      if (handle != null)
+      {
+        handle.Set(propertyId.Handle, value);
+      }
+    }
+
+    // Removes property value by property name.
+    public static void Remove<T>(IReactPropertyBag handle, ReactPropertyId<T> propertyId)
+    {
+      if (handle != null)
+      {
+        handle.Set(propertyId.Handle, null);
+      }
+    }
+
+    // Get property value by property name.
+    public T Get<T>(ReactPropertyId<T> propertyId)
+    {
+      return Get(Handle, propertyId);
+    }
+
+    // Ensure that property is created by calling valueCreator if needed,
+    // and return value by property name. The TCreateValue must return
+    // either T or std::optional<T>. It must have no parameters.
+    public T GetOrCreate<T>(ReactPropertyId<T> propertyId, Func<T> createValue)
+    {
+      return GetOrCreate(Handle, propertyId, createValue);
+    }
+
+    // Set property value by property name.
+    public void Set<T>(ReactPropertyId<T> propertyId, T value)
+    {
+      Set(Handle, propertyId, value);
+    }
+
+    // Removes property value by property name.
+    public void Remove<T>(ReactPropertyId<T> propertyId)
+    {
+      Remove(Handle, propertyId);
+    }
+  }
+}

package/Microsoft.ReactNative.Managed/ReactPropertyIdOf.cs

@@ -0,0 +1,44 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+using System;
+
+namespace Microsoft.ReactNative.Managed
+{
+  public struct ReactPropertyId<T>
+  {
+    public ReactPropertyName PropertyName { get; }
+
+    public ReactPropertyNamespace Namespace => PropertyName.Namespace;
+
+    public string NamespaceName => PropertyName.NamespaceName;
+
+    public string LocalName => PropertyName.LocalName;
+
+    public IReactPropertyName Handle => PropertyName.Handle;
+
+    public bool IsValid => PropertyName.IsValid;
+
+    public static explicit operator bool(ReactPropertyId<T> propertyId) => propertyId.IsValid;
+
+    public ReactPropertyId(ReactPropertyName propertyName)
+    {
+      PropertyName = propertyName;
+    }
+
+    public ReactPropertyId(IReactPropertyName handle = null)
+      : this(new ReactPropertyName(handle)) { }
+
+    public ReactPropertyId(string localName)
+      : this(new ReactPropertyName(localName)) { }
+
+    public ReactPropertyId(string namespaceName, string localName)
+      : this(new ReactPropertyName(namespaceName, localName)) { }
+
+    public ReactPropertyId(ReactPropertyNamespace ns, string localName)
+  : this(new ReactPropertyName(ns, localName)) { }
+
+    public ReactPropertyId(IReactPropertyNamespace ns, string localName)
+      : this(new ReactPropertyName(ns, localName)) { }
+  }
+}

package/Microsoft.ReactNative.Managed/ReactPropertyName.cs

@@ -0,0 +1,39 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+namespace Microsoft.ReactNative.Managed
+{
+  public struct ReactPropertyName
+  {
+    public ReactPropertyNamespace Namespace => new ReactPropertyNamespace(IsValid ? Handle.Namespace : null);
+
+    public string NamespaceName => IsValid ? Handle.Namespace.NamespaceName : null;
+
+    public string LocalName => IsValid ? Handle.LocalName : null;
+
+    public IReactPropertyName Handle { get; }
+
+    public bool IsValid => Handle != null;
+
+    public static explicit operator bool(ReactPropertyName propertyName) => propertyName.IsValid;
+
+    public ReactPropertyName(IReactPropertyName handle = null)
+    {
+      Handle = handle;
+    }
+
+    public ReactPropertyName(string localName)
+      : this((IReactPropertyNamespace)null, localName) { }
+
+    public ReactPropertyName(string namespaceName, string localName)
+      : this(ReactPropertyBagHelper.GetNamespace(namespaceName), localName) { }
+
+    public ReactPropertyName(ReactPropertyNamespace ns, string localName)
+      : this(ns.Handle, localName) { }
+
+    public ReactPropertyName(IReactPropertyNamespace ns, string localName)
+    {
+      Handle = ReactPropertyBagHelper.GetName(ns, localName);
+    }
+  }
+}

package/Microsoft.ReactNative.Managed/ReactPropertyNamespace.cs

@@ -0,0 +1,26 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+namespace Microsoft.ReactNative.Managed
+{
+  public struct ReactPropertyNamespace
+  {
+    public IReactPropertyNamespace Handle { get; }
+
+    public bool IsValid => Handle != null;
+
+    public string NamespaceName => IsValid ? Handle.NamespaceName : null;
+
+    public static explicit operator bool(ReactPropertyNamespace propertyNamespace) => propertyNamespace.IsValid;
+
+    public ReactPropertyNamespace(IReactPropertyNamespace handle = null)
+    {
+      Handle = handle;
+    }
+
+    public ReactPropertyNamespace(string namespaceName)
+    {
+      Handle = ReactPropertyBagHelper.GetNamespace(namespaceName);
+    }
+  }
+}

package/Microsoft.ReactNative.Managed/ReactSettingsSnapshot.cs

@@ -0,0 +1,44 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+using System.Reflection.Metadata;
+using System.Runtime.CompilerServices;
+
+namespace Microsoft.ReactNative.Managed
+{
+  public struct ReactSettingsSnapshot
+  {
+    public string BundleRootPath => IsValid ? Handle.BundleRootPath : null;
+
+    public string DebugBundlePath => IsValid ? Handle.DebugBundlePath : null;
+
+    public bool DebuggerBreakOnNextLine => IsValid ? Handle.DebuggerBreakOnNextLine : false;
+
+    public ushort DebuggerPort => IsValid ? Handle.DebuggerPort : (ushort)0;
+
+    public string JavaScriptBundleFile => IsValid ? Handle.JavaScriptBundleFile : null;
+
+    public bool RequestInlineSourceMap => IsValid ? Handle.RequestInlineSourceMap : false;
+
+    public string SourceBundleHost => IsValid ? Handle.SourceBundleHost : null;
+
+    public ushort SourceBundlePort => IsValid ? Handle.SourceBundlePort : (ushort)0;
+
+    public bool UseDirectDebugger => IsValid ? Handle.UseDirectDebugger : false;
+
+    public bool UseFastRefresh => IsValid ? Handle.UseFastRefresh : false;
+
+    public bool UseWebDebugger => IsValid ? Handle.UseWebDebugger : false;
+
+    public IReactSettingsSnapshot Handle { get; }
+
+    public bool IsValid => Handle != null;
+
+    public static explicit operator bool(ReactSettingsSnapshot settingsSnapshot) => settingsSnapshot.IsValid;
+
+    public ReactSettingsSnapshot(IReactSettingsSnapshot handle = null)
+    {
+      Handle = handle;
+    }
+  }
+}

package/Microsoft.ReactNative.Managed/ReactTaskExtensions.cs

@@ -32,8 +32,7 @@ namespace Microsoft.ReactNative.Managed
         {
           if (reject != null)
           {
-            var exception = t.Exception.Flatten();
-            WriteReject(writer, exception);
+            WriteReject(writer, t.Exception);
             reject(writer);
           }
         }
@@ -64,14 +63,26 @@ namespace Microsoft.ReactNative.Managed
         {
           if (reject != null)
           {
-            var exception = t.Exception.Flatten();
-            WriteReject(writer, exception);
+            WriteReject(writer, t.Exception);
             reject(writer);
           }
         }
       });
     }
 
+    private static void WriteReject(IJSValueWriter writer, AggregateException exception)
+    {
+      var innerExceptions = exception.InnerExceptions;
+      if (innerExceptions.Count == 1)
+      {
+        WriteReject(writer, innerExceptions[0]);
+      }
+      else
+      {
+        WriteReject(writer, exception.Flatten());
+      }
+    }
+
     private static void WriteReject(IJSValueWriter writer, Exception exception)
     {
       ReactPromiseWriter.WriteError(writer,

package/Microsoft.ReactNative.Managed/packages.lock.json

@@ -24,6 +24,11 @@
           "Microsoft.SourceLink.Common": "1.0.0"
         }
       },
+      "boost": {
+        "type": "Transitive",
+        "resolved": "1.76.0",
+        "contentHash": "p+w3YvNdXL8Cu9Fzrmexssu0tZbWxuf6ywsQqHjDlKFE5ojXHof1HIyMC3zDLfLnh80dIeFcEUAuR2Asg/XHRA=="
+      },
       "Microsoft.Build.Tasks.Git": {
         "type": "Transitive",
         "resolved": "1.0.0",
@@ -53,13 +58,23 @@
       "Microsoft.NETCore.Platforms": {
         "type": "Transitive",
         "resolved": "2.1.0",
-        "contentHash": "GmkKfoyerqmsHMn7OZj0AKpcBabD+GaafqphvX2Mw406IwiJRy1pKcKqdCfKJfYmkRyJ6+e+RaUylgdJoDa1jQ=="
+        "contentHash": "ok+RPAtESz/9MUXeIEz6Lv5XAGQsaNmEYXMsgVALj4D7kqC8gveKWXWXbufLySR2fWrwZf8smyN5RmHu0e4BHA=="
       },
       "Microsoft.SourceLink.Common": {
         "type": "Transitive",
         "resolved": "1.0.0",
         "contentHash": "G8DuQY8/DK5NN+3jm5wcMcd9QYD90UV7MiLmdljSJixi3U/vNaeBKmmXUqI4DJCOeWizIUEh4ALhSt58mR+5eg=="
       },
+      "Microsoft.UI.Xaml": {
+        "type": "Transitive",
+        "resolved": "2.7.0",
+        "contentHash": "dB4im13tfmMgL/V3Ei+3kD2rUF+/lTxAmR4gjJ45l577eljHfdo/KUrxpq/3I1Vp6e5GCDG1evDaEGuDxypLMg=="
+      },
+      "Microsoft.Windows.SDK.BuildTools": {
+        "type": "Transitive",
+        "resolved": "10.0.22000.194",
+        "contentHash": "4L0P3zqut466SIqT3VBeLTNUQTxCBDOrTRymRuROCRJKazcK7ibLz9yAO1nKWRt50ttCj39oAa2Iuz9ZTDmLlg=="
+      },
       "NETStandard.Library": {
         "type": "Transitive",
         "resolved": "2.0.3",
@@ -68,6 +83,11 @@
           "Microsoft.NETCore.Platforms": "1.1.0"
         }
       },
+      "ReactNative.Hermes.Windows": {
+        "type": "Transitive",
+        "resolved": "0.0.0-2210.24002-3d61ad03",
+        "contentHash": "q38h/Gkw8d0pfUqIhRCd1j/XLhpQY4Hm7kSQthZUzetEST34acbR883/Eh+DKt4FVz9a0lh5kiAfP7piO768SA=="
+      },
       "runtime.win10-arm.Microsoft.Net.Native.Compiler": {
         "type": "Transitive",
         "resolved": "2.2.7-rel-27913-00",
@@ -135,8 +155,37 @@
         "resolved": "2.2.9",
         "contentHash": "qF6RRZKaflI+LR1YODNyWYjq5YoX8IJ2wx5y8O+AW2xO+1t/Q6Mm+jQ38zJbWnmXbrcOqUYofn7Y3/KC6lTLBQ=="
       },
-      "microsoft.reactnative": {
+      "common": {
+        "type": "Project"
+      },
+      "fmt": {
         "type": "Project"
+      },
+      "folly": {
+        "type": "Project",
+        "dependencies": {
+          "boost": "[1.76.0, )",
+          "fmt": "[1.0.0, )"
+        }
+      },
+      "microsoft.reactnative": {
+        "type": "Project",
+        "dependencies": {
+          "Common": "[1.0.0, )",
+          "Folly": "[1.0.0, )",
+          "Microsoft.UI.Xaml": "[2.7.0, )",
+          "Microsoft.Windows.SDK.BuildTools": "[10.0.22000.194, )",
+          "ReactCommon": "[1.0.0, )",
+          "ReactNative.Hermes.Windows": "[0.0.0-2210.24002-3d61ad03, )",
+          "boost": "[1.76.0, )"
+        }
+      },
+      "reactcommon": {
+        "type": "Project",
+        "dependencies": {
+          "Folly": "[1.0.0, )",
+          "boost": "[1.76.0, )"
+        }
       }
     },
     "UAP,Version=v10.0.16299/win10-arm": {

package/Microsoft.ReactNative.Managed.CodeGen/App.cs

@@ -111,7 +111,7 @@ namespace Microsoft.ReactNative.Managed.CodeGen
                 }
 
                 // Ensure output directory
-                Directory.CreateDirectory(Path.GetDirectoryName(path));
+                Directory.CreateDirectory(Path.GetDirectoryName(path)!);
 
                 await File.WriteAllTextAsync(path, contents, m_cancellationToken);