@lvce-editor/eslint-plugin-virtual-dom 16.5.0 → 17.0.1

package/dist/index.js

@@ -77,7 +77,7 @@ const isStringLiteral = node => {
   return isLiteralNode(node) && typeof node.value === 'string';
 };
 
-const meta$b = {
+const meta$c = {
   docs: {
     description: 'Require an explicit role on clickable virtual-dom div nodes'
   },
@@ -86,7 +86,7 @@ const meta$b = {
   },
   type: 'problem'
 };
-const create$b = context => {
+const create$c = context => {
   return {
     ObjectExpression(node) {
       if (!isVirtualDomNode(node)) {
@@ -107,6 +107,114 @@ const create$b = context => {
 };
 
 const clickableDivNeedsRole = {
+  __proto__: null,
+  create: create$c,
+  meta: meta$c
+};
+
+const meta$b = {
+  docs: {
+    description: 'Require static virtual-dom nodes created inside functions to be hoisted to module scope'
+  },
+  messages: {
+    hoistStaticNode: 'Hoist this static virtual-dom node to module scope.'
+  },
+  type: 'suggestion'
+};
+const isFunctionNode$1 = node => {
+  return ['ArrowFunctionExpression', 'FunctionDeclaration', 'FunctionExpression'].includes(node.type);
+};
+const findVariable = (sourceCode, identifier) => {
+  let scope = sourceCode.getScope(identifier);
+  while (scope) {
+    const variable = scope.set.get(identifier.name);
+    if (variable) {
+      return variable;
+    }
+    scope = scope.upper;
+  }
+  return undefined;
+};
+const isStaticModuleVariable = variable => {
+  if (!['global', 'module'].includes(variable.scope.type)) {
+    return false;
+  }
+  return variable.defs.every(definition => {
+    if (['ClassName', 'FunctionName', 'ImportBinding'].includes(definition.type)) {
+      return true;
+    }
+    return definition.type === 'Variable' && definition.parent.kind === 'const';
+  });
+};
+const isStaticIdentifier = (sourceCode, node) => {
+  const variable = findVariable(sourceCode, node);
+  return Boolean(variable && isStaticModuleVariable(variable));
+};
+const isVirtualDomElement = node => {
+  if (!isVirtualDomNode(node) || !hasProperty(node, 'childCount')) {
+    return false;
+  }
+  const type = getProperty(node, 'type');
+  return Boolean(type && !isStringLiteral(type.value));
+};
+const isStaticProperty = (sourceCode, node) => {
+  if (node.type === 'SpreadElement' || node.kind !== 'init' || node.method) {
+    return false;
+  }
+  if (node.computed && !isStaticExpression(sourceCode, node.key)) {
+    return false;
+  }
+  return isStaticExpression(sourceCode, node.value);
+};
+const isStaticExpression = (sourceCode, node) => {
+  if (!node) {
+    return true;
+  }
+  switch (node.type) {
+    case 'ArrayExpression':
+      return node.elements.every(element => !element || element.type !== 'SpreadElement' && isStaticExpression(sourceCode, element));
+    case 'BinaryExpression':
+    case 'LogicalExpression':
+      return isStaticExpression(sourceCode, node.left) && isStaticExpression(sourceCode, node.right);
+    case 'ConditionalExpression':
+      return isStaticExpression(sourceCode, node.test) && isStaticExpression(sourceCode, node.consequent) && isStaticExpression(sourceCode, node.alternate);
+    case 'Identifier':
+      return isStaticIdentifier(sourceCode, node);
+    case 'Literal':
+      return true;
+    case 'MemberExpression':
+      return isStaticExpression(sourceCode, node.object) && (!node.computed || node.property.type !== 'PrivateIdentifier' && isStaticExpression(sourceCode, node.property));
+    case 'ObjectExpression':
+      return node.properties.every(property => isStaticProperty(sourceCode, property));
+    case 'TemplateLiteral':
+      return node.expressions.every(expression => isStaticExpression(sourceCode, expression));
+    case 'UnaryExpression':
+      return node.operator !== 'delete' && isStaticExpression(sourceCode, node.argument);
+    default:
+      return false;
+  }
+};
+const create$b = context => {
+  return {
+    ObjectExpression(node) {
+      if (!isVirtualDomElement(node)) {
+        return;
+      }
+      if (!context.sourceCode.getAncestors(node).some(isFunctionNode$1)) {
+        return;
+      }
+      if (!isStaticExpression(context.sourceCode, node)) {
+        return;
+      }
+      context.report({
+        messageId: 'hoistStaticNode',
+        node
+      });
+    }
+  };
+};
+
+const hoistStaticNodes = {
   __proto__: null,
   create: create$b,
   meta: meta$b
@@ -452,6 +560,9 @@ const preferLazyDateTimeFormat = {
 const isClassNameKey = node => {
   return getStaticPropertyName(node) === 'className';
 };
+const isClassNameProperty = node => {
+  return isPropertyNode(node) && isClassNameKey(node);
+};
 const isStringLiteralWithSpace = node => {
   return isStringLiteral(node) && /\s/.test(node.value);
 };
@@ -473,6 +584,24 @@ const isManualClassNameConcatenation = node => {
   }
   return isStringLiteralWithSpace(node.left) || isStringLiteralWithSpace(node.right) || isManualClassNameConcatenation(node.left) || isManualClassNameConcatenation(node.right);
 };
+const hasClassNamesReference = node => {
+  if (isMemberExpressionNode(node)) {
+    return isIdentifierNode(node.object) && node.object.name === 'ClassNames' || hasClassNamesReference(node.object) || node.computed && hasClassNamesReference(node.property);
+  }
+  if (isBinaryExpressionNode(node)) {
+    return hasClassNamesReference(node.left) || hasClassNamesReference(node.right);
+  }
+  if (isTemplateLiteralNode(node)) {
+    return node.expressions.some(hasClassNamesReference);
+  }
+  return false;
+};
+const getParent = node => {
+  if (typeof node === 'object' && node !== null && 'parent' in node) {
+    return node.parent;
+  }
+  return undefined;
+};
 const meta$2 = {
   docs: {
     description: 'Prefer mergeClassNames for composing virtual-dom className values'
@@ -483,7 +612,21 @@ const meta$2 = {
   type: 'suggestion'
 };
 const create$2 = context => {
+  const reportNamespacedClassNameComposition = node => {
+    if (!isManualClassNameConcatenation(node) || !hasClassNamesReference(node)) {
+      return;
+    }
+    const parent = getParent(node);
+    if (isManualClassNameConcatenation(parent) || isClassNameProperty(parent)) {
+      return;
+    }
+    context.report({
+      messageId: 'preferMergeClassNames',
+      node: node
+    });
+  };
   return {
+    BinaryExpression: reportNamespacedClassNameComposition,
     Property(node) {
       if (!isPropertyNode(node) || !isClassNameKey(node) || !isManualClassNameConcatenation(node.value)) {
         return;
@@ -492,7 +635,8 @@ const create$2 = context => {
         messageId: 'preferMergeClassNames',
         node: node.value
       });
-    }
+    },
+    TemplateLiteral: reportNamespacedClassNameComposition
   };
 };
 
@@ -678,6 +822,7 @@ const plugin = {
   },
   rules: {
     'clickable-div-needs-role': clickableDivNeedsRole,
+    'hoist-static-nodes': hoistStaticNodes,
     'no-empty-aria': noEmptyAria,
     'no-empty-class-name': noEmptyClassName,
     'no-inline-event-handlers': noInlineEventHandlers,
@@ -698,6 +843,7 @@ const recommended = [{
   },
   rules: {
     'virtual-dom/clickable-div-needs-role': 'error',
+    'virtual-dom/hoist-static-nodes': 'error',
     'virtual-dom/no-empty-aria': 'error',
     'virtual-dom/no-empty-class-name': 'error',
     'virtual-dom/no-inline-event-handlers': 'error',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lvce-editor/eslint-plugin-virtual-dom",
-  "version": "16.5.0",
+  "version": "17.0.1",
   "main": "dist/index.js",
   "repository": {
     "type": "git",