Only expose JsInterop methods to Vue.js

Before, all the methods that were at least package-protected where
visible in JS. This could cause confusion when reading the Component
class, as well as exposing some unwanted methods.

Author: adrienbaron

src/main/java/com/axellience/vuegwt/jsr69/component/ComponentGenerationUtil.java

@@ -150,13 +150,13 @@ public static TypeName resolveVariableTypeName(VariableElement variableElement,
      */
     public static boolean isMethodVisibleInTemplate(ExecutableElement method)
     {
-        return !hasAnnotation(method, Computed.class)
+        return isMethodVisibleInJS(method)
+            && !hasAnnotation(method, Computed.class)
             && !hasAnnotation(method, Watch.class)
             && !hasAnnotation(method, PropValidator.class)
             && !hasAnnotation(method, PropDefault.class)
             && !method.getModifiers().contains(Modifier.STATIC)
-            && !method.getModifiers().contains(Modifier.PRIVATE)
-            && !method.getModifiers().contains(Modifier.ABSTRACT);
+            && !method.getModifiers().contains(Modifier.PRIVATE);
     }
 
     /**
@@ -166,13 +166,13 @@ public static boolean isMethodVisibleInTemplate(ExecutableElement method)
      */
     public static boolean isMethodVisibleInTemplate(JMethod method)
     {
-        return !hasAnnotation(method, Computed.class)
+        return isMethodVisibleInJS(method)
+            && !hasAnnotation(method, Computed.class)
             && !hasAnnotation(method, Watch.class)
             && !hasAnnotation(method, PropValidator.class)
             && !hasAnnotation(method, PropDefault.class)
             && !method.isStatic()
-            && !method.isPrivate()
-            && !method.isAbstract();
+            && !method.isPrivate();
     }
 
     /**
@@ -217,6 +217,20 @@ public static boolean isFieldVisibleInJS(JField field)
             || hasAnnotation(field, JsProperty.class);
     }
 
+    /**
+     * Return weather a given method is visible in JS (JsInterop).
+     * It will be the case if it's public and it's class/interface has the {@link JsType}
+     * annotation, or
+     * if it has the {@link JsMethod} annotation.
+     * @param method The method to check
+     * @return true if it is visible (JsInterop), false otherwise
+     */
+    public static boolean isMethodVisibleInJS(JMethod method)
+    {
+        return (hasAnnotation(method.getEnclosingType(), JsType.class) && method.isPublic())
+            || hasAnnotation(method, JsMethod.class);
+    }
+
     /**
      * Return the {@link TypeElement} of the parent {@link VueComponent} of a given {@link
      * VueComponent}.

src/main/java/com/axellience/vuegwt/jsr69/component/ComponentJsTypeGenerator.java

@@ -102,10 +102,7 @@ public void generate(TypeElement component)
         processPropValidators(component, optionsBuilder, componentJsTypeBuilder);
         processPropDefaultValues(component, optionsBuilder, componentJsTypeBuilder);
         processHooks(component, optionsBuilder, hookMethodsFromInterfaces);
-        processTemplateMethods(component,
-            optionsBuilder,
-            componentJsTypeBuilder,
-            hookMethodsFromInterfaces);
+        processTemplateMethods(component, optionsBuilder, hookMethodsFromInterfaces);
         processRenderFunction(component, optionsBuilder, componentJsTypeBuilder);
         createCreatedHook(component, optionsBuilder, componentJsTypeBuilder, dependenciesBuilder);
 
@@ -291,17 +288,15 @@ private void processComputed(TypeElement component, MethodSpec.Builder optionsBu
     }
 
     /**
-     * Process template methods for our {@link VueComponent} class. Make them visible to JS by
-     * wrapping them if necessary.
+     * Process template methods for our {@link VueComponent} class.
      * @param component {@link VueComponent} to process
      * @param optionsBuilder A {@link MethodSpec.Builder} for the method that creates the
      * {@link VueComponentOptions}
-     * @param componentJsTypeBuilder Builder for the JsType class
      * @param hookMethodsFromInterfaces Hook methods from the interface the {@link VueComponent}
      * implements
      */
     private void processTemplateMethods(TypeElement component, MethodSpec.Builder optionsBuilder,
-        Builder componentJsTypeBuilder, Set<ExecutableElement> hookMethodsFromInterfaces)
+        Set<ExecutableElement> hookMethodsFromInterfaces)
     {
         List<ExecutableElement> templateMethods = ElementFilter
             .methodsIn(component.getEnclosedElements())
@@ -310,13 +305,6 @@ private void processTemplateMethods(TypeElement component, MethodSpec.Builder op
             .filter(method -> !isHookMethod(component, method, hookMethodsFromInterfaces))
             .collect(Collectors.toList());
 
-        // Make methods visible in JS
-        templateMethods
-            .stream()
-            .filter(method -> !isMethodVisibleInJS(method))
-            .map(this::createProxyJsTypeMethod)
-            .forEach(componentJsTypeBuilder::addMethod);
-
         // Declare methods in the component
         String methodNamesParameters = templateMethods
             .stream()