Use the pragma setting instead of React

Author: jomasti

lib/rules/void-dom-elements-no-children.js

@@ -99,7 +99,7 @@ module.exports = {
         return;
       }
 
-      if (!utils.isReactCreateElement(node)) {
+      if (!utils.isPragmaCreateElement(node)) {
         return;
       }
 

lib/util/Components.js

@@ -255,33 +255,33 @@ function componentRule(rule, context) {
     },
 
     /**
-     * Check if variable is destructured from React import
+     * Check if variable is destructured from pragma import
      *
      * @param {variable} String The variable name to check
-     * @returns {Boolean} True if createElement is destructured from React
+     * @returns {Boolean} True if createElement is destructured from the pragma
      */
-    isDestructuredFromReactImport: function(variable) {
+    isDestructuredFromPragmaImport: function(variable) {
       const variables = variableUtil.variablesInScope(context);
       const variableInScope = variableUtil.getVariable(variables, variable);
       if (variableInScope) {
         const map = variableInScope.scope.set;
-        return map.has('React');
+        return map.has(pragma);
       }
       return false;
     },
 
     /**
-     * Checks to see if node is called within React.createElement
+     * Checks to see if node is called within createElement from pragma
      *
      * @param {ASTNode} node The AST node being checked.
-     * @returns {Boolean} True if React.createElement called
+     * @returns {Boolean} True if createElement called from pragma
      */
-    isReactCreateElement: function(node) {
-      const calledOnReact = (
+    isPragmaCreateElement: function(node) {
+      const calledOnPragma = (
         node &&
         node.callee &&
         node.callee.object &&
-        node.callee.object.name === 'React' &&
+        node.callee.object.name === pragma &&
         node.callee.property &&
         node.callee.property.name === 'createElement'
       );
@@ -292,10 +292,10 @@ function componentRule(rule, context) {
         node.callee.name === 'createElement'
       );
 
-      if (this.isDestructuredFromReactImport('createElement')) {
-        return calledDirectly || calledOnReact;
+      if (this.isDestructuredFromPragmaImport('createElement')) {
+        return calledDirectly || calledOnPragma;
       }
-      return calledOnReact;
+      return calledOnPragma;
     },
 
     getReturnPropertyAndNode(ASTnode) {
@@ -357,12 +357,12 @@ function componentRule(rule, context) {
         node[property] &&
         jsxUtil.isJSX(node[property])
       ;
-      const returnsReactCreateElement = this.isReactCreateElement(node[property]);
+      const returnsPragmaCreateElement = this.isPragmaCreateElement(node[property]);
 
       return Boolean(
         returnsConditionalJSX ||
         returnsJSX ||
-        returnsReactCreateElement
+        returnsPragmaCreateElement
       );
     },
 
@@ -395,16 +395,16 @@ function componentRule(rule, context) {
       return utils.isReturningJSX(ASTNode, strict) || utils.isReturningNull(ASTNode);
     },
 
-    isReactComponentWrapper(node) {
+    isPragmaComponentWrapper(node) {
       if (node.type !== 'CallExpression') {
         return false;
       }
       const propertyNames = ['forwardRef', 'memo'];
       const calleeObject = node.callee.object;
       if (calleeObject) {
-        return arrayIncludes(propertyNames, node.callee.property.name) && node.callee.object.name === 'React';
+        return arrayIncludes(propertyNames, node.callee.property.name) && node.callee.object.name === pragma;
       }
-      return arrayIncludes(propertyNames, node.callee.name) && this.isDestructuredFromReactImport(node.callee.name);
+      return arrayIncludes(propertyNames, node.callee.name) && this.isDestructuredFromPragmaImport(node.callee.name);
     },
 
     /**
@@ -476,7 +476,7 @@ function componentRule(rule, context) {
         const enclosingScopeParent = enclosingScope && enclosingScope.block.parent;
         const isClass = enclosingScope && astUtil.isClass(enclosingScope.block);
         const isMethod = enclosingScopeParent && enclosingScopeParent.type === 'MethodDefinition'; // Classes methods
-        const isArgument = node.parent && node.parent.type === 'CallExpression' && !this.isReactComponentWrapper(node.parent); // Arguments (callback, etc.)
+        const isArgument = node.parent && node.parent.type === 'CallExpression' && !this.isPragmaComponentWrapper(node.parent); // Arguments (callback, etc.)
         // Attribute Expressions inside JSX Elements (<button onClick={() => props.handleClick()}></button>)
         const isJSXExpressionContainer = node.parent && node.parent.type === 'JSXExpressionContainer';
         // Stop moving up if we reach a class or an argument (like a callback)