added prefab component

Author: KurtGokhan

Runtime/Core/BaseReactComponent.cs

@@ -291,6 +291,7 @@ public void ApplyLayoutStyles()
             ApplyLayoutStylesSelf();
         }
 
+        public abstract void Relayout();
 
         private void OnStylesUpdated(NodeStyle obj, bool hasLayout)
         {

Runtime/Core/ComponentInterfaces.cs

@@ -33,6 +33,7 @@ public interface IReactComponent
         void ApplyLayoutStyles();
         void ScheduleLayout();
         void ResolveStyle(bool recursive = false);
+        void Relayout();
 
         void Update();
         void Accept(ReactComponentVisitor visitor);

Runtime/Core/ReactUnityBridge.cs

@@ -1,5 +1,3 @@
-using Jint.Native;
-using Jint.Native.Function;
 using ReactUnity.Helpers.TypescriptUtils;
 using ReactUnity.Helpers;
 using System;
@@ -83,19 +81,10 @@ public void setData(object element, string property, object value)
                 c.SetData(property, value);
         }
 
-        public void setEventListener(IReactComponent element, string eventType, JsValue value)
-        {
-            var hasValue = value != null && !value.IsNull() && !value.IsUndefined() && !value.IsBoolean();
-            var callback = value.As<FunctionInstance>();
-            if (hasValue && callback == null) throw new Exception("The callback for an event must be a function.");
-
-            element.SetEventListener(eventType, new Callback(callback));
-        }
-
         public void setEventListener(object element, string eventType, object value)
         {
-            if (element is IReactComponent c && value != null)
-                c.SetEventListener(eventType, new Callback(value));
+            if (element is IReactComponent c)
+                c.SetEventListener(eventType, Callback.From(value));
         }
 
         #endregion

Runtime/Frameworks/UGUI/Components/PrefabComponent.cs

@@ -0,0 +1,137 @@
+using Facebook.Yoga;
+using ReactUnity.Helpers;
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace ReactUnity.UGUI
+{
+    public class PrefabComponent : UGUIComponent
+    {
+        GameObject currentTarget;
+        public GameObject Instance { get; private set; }
+        private RectTransform InstanceTransform;
+        private Transform InstanceParent;
+        private bool InstanceWasPrefab;
+        IPrefabTarget TargetHandler;
+
+        Callback onMount;
+        Callback onUnmount;
+
+        public PrefabComponent(UGUIContext context, string tag = "prefab") : base(context, tag)
+        {
+            Layout.SetMeasureFunction(Measure);
+        }
+
+        private YogaSize Measure(YogaNode node, float width, YogaMeasureMode widthMode, float height, YogaMeasureMode heightMode)
+        {
+            if (!InstanceTransform) return new YogaSize { width = 0, height = 0 };
+
+            return new YogaSize
+            {
+                width = InstanceTransform.rect.width,
+                height = InstanceTransform.rect.height,
+            };
+        }
+
+        void SetTarget(GameObject target)
+        {
+            if (currentTarget == target) return;
+
+            if (currentTarget)
+            {
+                TargetHandler?.Unmount(this);
+                onUnmount?.Call(currentTarget, this);
+                currentTarget = null;
+                TargetHandler = null;
+
+                if (Instance)
+                {
+                    if (InstanceWasPrefab) GameObject.Destroy(Instance);
+                    else Instance.transform.SetParent(InstanceParent, false);
+                }
+                Instance = null;
+                InstanceTransform = null;
+                InstanceParent = null;
+            }
+
+            currentTarget = target;
+
+            if (currentTarget)
+            {
+                ResolveInstance();
+
+                Instance.transform.SetParent(Container, false);
+                TargetHandler?.Mount(this);
+                onMount?.Call(currentTarget, this);
+            }
+
+            Relayout();
+        }
+
+        void ResolveInstance()
+        {
+            if (!currentTarget) return;
+
+            var isPrefab = currentTarget.scene.rootCount == 0;
+
+            if (isPrefab)
+            {
+                Instance = null;
+#if UNITY_EDITOR
+                Instance = UnityEditor.PrefabUtility.InstantiatePrefab(currentTarget, Container) as GameObject;
+#endif
+                if (!Instance) Instance = GameObject.Instantiate(currentTarget);
+                InstanceParent = null;
+                InstanceWasPrefab = true;
+            }
+            else
+            {
+                Instance = currentTarget;
+                InstanceParent = currentTarget.transform.parent;
+                InstanceWasPrefab = false;
+            }
+            InstanceTransform = Instance.transform as RectTransform;
+
+            TargetHandler = currentTarget.GetComponent<IPrefabTarget>();
+        }
+
+        GameObject FindTarget(object value)
+        {
+            if (value == null) return null;
+            if (value is GameObject g && g) return g;
+            if (value is Component c && c) return c.gameObject;
+            return null;
+        }
+
+        public override void SetProperty(string propertyName, object value)
+        {
+            switch (propertyName)
+            {
+                case "target":
+                    SetTarget(FindTarget(value));
+                    break;
+                default:
+                    var handled = TargetHandler != null ? TargetHandler.SetProperty(propertyName, value) : false;
+                    if (!handled) base.SetProperty(propertyName, value);
+                    break;
+            }
+        }
+
+        public override void SetEventListener(string eventName, Callback callback)
+        {
+            switch (eventName)
+            {
+                case "onMount":
+                    onMount = callback;
+                    return;
+                case "onUnmount":
+                    onUnmount = callback;
+                    return;
+                default:
+                    var handled = TargetHandler != null ? TargetHandler.SetEventListener(eventName, callback) : false;
+                    if (!handled) base.SetEventListener(eventName, callback);
+                    return;
+            }
+        }
+    }
+}

Runtime/Frameworks/UGUI/Components/PrefabComponent.cs.meta

@@ -129,6 +129,12 @@ protected override void ApplyStylesSelf()
             UpdateBackgroundGraphic(false, true);
         }
 
+        public override void Relayout()
+        {
+            Layout.MarkDirty();
+            Context.ScheduleLayout();
+        }
+
         #endregion
 
 

Runtime/Frameworks/UGUI/Components/UGUIComponent.cs

@@ -0,0 +1,63 @@
+using ReactUnity.Helpers;
+using System;
+using UnityEngine.Events;
+using UnityEngine.EventSystems;
+
+namespace ReactUnity.UGUI
+{
+    public class PrefabTarget : UIBehaviour, IPrefabTarget
+    {
+        public PrefabComponent MountedTo;
+        public PrefabEvent OnMount;
+        public PrefabEvent OnUnmount;
+        public SetPropertyEvent OnSetProperty;
+        public SetEventListenerEvent OnSetEventListener;
+
+        protected override void OnRectTransformDimensionsChange()
+        {
+            MountedTo?.Relayout();
+        }
+
+        public virtual void Mount(PrefabComponent cmp)
+        {
+            MountedTo = cmp;
+            OnMount?.Invoke(cmp, this);
+        }
+
+        public virtual void Unmount(PrefabComponent cmp)
+        {
+            OnUnmount?.Invoke(cmp, this);
+            MountedTo = null;
+        }
+
+        public virtual bool SetEventListener(string eventName, Callback callback)
+        {
+            OnSetEventListener?.Invoke(eventName, callback);
+            return OnSetEventListener != null;
+        }
+
+        public virtual bool SetProperty(string propertyName, object value)
+        {
+            OnSetProperty?.Invoke(propertyName, value);
+            return OnSetProperty != null;
+        }
+
+        [Serializable]
+        public class PrefabEvent : UnityEvent<PrefabComponent, PrefabTarget> { }
+    }
+
+    public interface IPrefabTarget
+    {
+        /* Return true to notify that this property is handled */
+        bool SetProperty(string propertyName, object value);
+
+        /* Return true to notify that this event is handled */
+        bool SetEventListener(string eventName, Callback callback);
+
+        /* Callback called when the target is mounted on the component */
+        void Mount(PrefabComponent cmp);
+
+        /* Callback called when the target is unmounted off the component */
+        void Unmount(PrefabComponent cmp);
+    }
+}

Runtime/Frameworks/UGUI/General.meta

@@ -14,7 +14,7 @@ public class TextMeasurer : MonoBehaviour, ILayoutSelfController
         public YogaNode Layout;
         public UGUIContext Context;
 
-        private void Start()
+        void Start()
         {
             if (Layout == null) DestroyImmediate(this);
         }