Wrap render method created using class properties (2) (#856)

* wrap render method created using class properties

* use Boolean instead of double not-operator

* patch-react: move a comment

client/patch-react.js

@@ -17,8 +17,23 @@ export default (handleError = () => {}) => {
   React.createElement = function (Component, ...rest) {
     if (typeof Component === 'function') {
       const { prototype } = Component
-      if (prototype && prototype.render) {
+
+      // assumes it's a class component if render method exists.
+      const isClassComponent = Boolean(prototype && prototype.render) ||
+        // subclass of React.Component or PureComponent with no render method.
+        // There's no render method in prototype
+        // when it's created with class-properties.
+        prototype instanceof React.Component ||
+        prototype instanceof React.PureComponent
+
+      if (isClassComponent) {
+        if (prototype.render) {
           prototype.render = wrapRender(prototype.render)
+        }
+
+        // wrap the render method in runtime when the component initialized
+        // for class-properties.
+        Component = wrap(Component, withWrapOwnRender)
       } else {
         // stateless component
         Component = wrapRender(Component)
@@ -39,24 +54,42 @@ export default (handleError = () => {}) => {
   }
 
   function wrapRender (render) {
-    if (render.__wrapped) {
-      return render.__wrapped
+    return wrap(render, withHandleError)
   }
 
-    const _render = function (...args) {
+  function withHandleError (fn, ...args) {
     try {
-        return render.apply(this, args)
+      return fn.apply(this, args)
     } catch (err) {
       handleError(err)
       return null
     }
   }
 
+  function withWrapOwnRender (fn, ...args) {
+    const result = fn.apply(this, args)
+    if (this.render && this.hasOwnProperty('render')) {
+      this.render = wrapRender(this.render)
+    }
+    return result
+  }
+}
+
+function wrap (fn, around) {
+  if (fn.__wrapped) {
+    return fn.__wrapped
+  }
+
+  const _fn = function (...args) {
+    return around.call(this, fn, ...args)
+  }
+
   // copy all properties
-    Object.assign(_render, render)
+  Object.assign(_fn, fn)
 
-    render.__wrapped = _render.__wrapped = _render
+  _fn.prototype = fn.prototype
 
-    return _render
-  }
+  _fn.__wrapped = fn.__wrapped = _fn
+
+  return _fn
 }