@lvce-editor/eslint-plugin-virtual-dom 17.1.0 → 17.3.0

package/dist/index.js

@@ -52,8 +52,19 @@ const getProperty = (node, name) => {
 const hasProperty = (node, name) => {
   return Boolean(getProperty(node, name));
 };
+const virtualDomElementNames = new Set(['A', 'Abbr', 'Article', 'Aside', 'Audio', 'Br', 'Button', 'Cite', 'Code', 'Col', 'ColGroup', 'Data', 'Dd', 'Del', 'Div', 'Dl', 'Dt', 'Figcaption', 'Figure', 'Footer', 'H1', 'H2', 'H3', 'H4', 'H5', 'H6', 'Header', 'Hr', 'I', 'Img', 'Input', 'Ins', 'Kbd', 'Label', 'Li', 'Nav', 'Ol', 'Option', 'P', 'Pre', 'Reference', 'Root', 'Search', 'Section', 'Select', 'Span', 'Table', 'TBody', 'Td', 'Text', 'TextArea', 'Tfoot', 'Th', 'THead', 'Time', 'Tr', 'Ul', 'Video']);
+const getVirtualDomElementName = node => {
+  if (!isMemberExpressionNode(node) || node.computed || !isIdentifierNode(node.object) || !isIdentifierNode(node.property) || !node.object.name.endsWith('Elements') || !virtualDomElementNames.has(node.property.name)) {
+    return undefined;
+  }
+  return node.property.name;
+};
 const isVirtualDomNode = node => {
-  return isObjectExpressionNode(node) && hasProperty(node, 'type');
+  if (!isObjectExpressionNode(node)) {
+    return false;
+  }
+  const typeProperty = getProperty(node, 'type');
+  return Boolean(typeProperty && (hasProperty(node, 'childCount') || getVirtualDomElementName(typeProperty.value)));
 };
 const isTextCall = node => {
   return isCallExpressionNode(node) && isIdentifierNode(node.callee) && node.callee.name === 'text';
@@ -77,7 +88,67 @@ const isStringLiteral = node => {
   return isLiteralNode(node) && typeof node.value === 'string';
 };
 
-const meta$c = {
+const controlsRequiringDirectName = new Set(['Input', 'TextArea']);
+const controlsAllowingChildren = new Set(['A', 'Button']);
+const hasDirectName = node => {
+  return Boolean(getProperty(node, 'ariaLabel') || getProperty(node, 'ariaLabelledBy') || getProperty(node, 'title'));
+};
+const meta$p = {
+  docs: {
+    description: 'Require a statically determinable accessible name for virtual-dom controls'
+  },
+  messages: {
+    accessibleControlName: 'Add an accessible name to this virtual-dom `{{name}}` control.'
+  },
+  type: 'problem'
+};
+const create$p = context => {
+  return {
+    ObjectExpression(node) {
+      if (!isVirtualDomNode(node) || hasDirectName(node)) {
+        return;
+      }
+      const typeProperty = getProperty(node, 'type');
+      const elementName = typeProperty && getVirtualDomElementName(typeProperty.value);
+      if (!elementName) {
+        return;
+      }
+      if (controlsRequiringDirectName.has(elementName)) {
+        context.report({
+          data: {
+            name: elementName
+          },
+          messageId: 'accessibleControlName',
+          node
+        });
+        return;
+      }
+      if (!controlsAllowingChildren.has(elementName)) {
+        return;
+      }
+      const childCountProperty = getProperty(node, 'childCount');
+      const childCount = childCountProperty && getStaticNumberValue(childCountProperty.value);
+      if (childCount !== 0) {
+        return;
+      }
+      context.report({
+        data: {
+          name: elementName
+        },
+        messageId: 'accessibleControlName',
+        node
+      });
+    }
+  };
+};
+
+const accessibleControlName = {
+  __proto__: null,
+  create: create$p,
+  meta: meta$p
+};
+
+const meta$o = {
   docs: {
     description: 'Require an explicit role on clickable virtual-dom div nodes'
   },
@@ -86,7 +157,7 @@ const meta$c = {
   },
   type: 'problem'
 };
-const create$c = context => {
+const create$o = context => {
   return {
     ObjectExpression(node) {
       if (!isVirtualDomNode(node)) {
@@ -108,11 +179,11 @@ const create$c = context => {
 
 const clickableDivNeedsRole = {
   __proto__: null,
-  create: create$c,
-  meta: meta$c
+  create: create$o,
+  meta: meta$o
 };
 
-const meta$b = {
+const meta$n = {
   docs: {
     description: 'Require static virtual-dom nodes created inside functions to be hoisted to module scope'
   },
@@ -223,7 +294,7 @@ const isStaticExpression = (sourceCode, node) => {
       return false;
   }
 };
-const create$b = context => {
+const create$n = context => {
   return {
     ObjectExpression(node) {
       if (!isVirtualDomElement(node)) {
@@ -248,11 +319,52 @@ const create$b = context => {
 
 const hoistStaticNodes = {
   __proto__: null,
-  create: create$b,
-  meta: meta$b
+  create: create$n,
+  meta: meta$n
 };
 
-const meta$a = {
+const meta$m = {
+  docs: {
+    description: 'Disallow conditional spreads in virtual-dom arrays'
+  },
+  messages: {
+    noConditionalSpread: 'Move conditional virtual-dom children into a helper function and spread the helper result.'
+  },
+  type: 'suggestion'
+};
+const isConditionalSpread = node => {
+  return node?.type === 'SpreadElement' && node.argument.type === 'ConditionalExpression';
+};
+const isVirtualDomArray$1 = node => {
+  return isArrayExpressionNode(node) && node.elements.some(element => isVirtualDomNode(element) || isTextCall(element));
+};
+const addsVirtualDomChildren = spread => {
+  return isVirtualDomArray$1(spread.argument.consequent) || isVirtualDomArray$1(spread.argument.alternate);
+};
+const create$m = context => {
+  return {
+    ArrayExpression(node) {
+      const conditionalSpreads = node.elements.filter(isConditionalSpread);
+      if (!isVirtualDomArray$1(node) && !conditionalSpreads.some(addsVirtualDomChildren)) {
+        return;
+      }
+      for (const spread of conditionalSpreads) {
+        context.report({
+          messageId: 'noConditionalSpread',
+          node: spread
+        });
+      }
+    }
+  };
+};
+
+const noConditionalSpread = {
+  __proto__: null,
+  create: create$m,
+  meta: meta$m
+};
+
+const meta$l = {
   docs: {
     description: 'Disallow empty ARIA values in virtual-dom nodes'
   },
@@ -264,7 +376,7 @@ const meta$a = {
 const isAriaProperty = name => {
   return /^aria[A-Z]/.test(name);
 };
-const create$a = context => {
+const create$l = context => {
   return {
     ObjectExpression(node) {
       if (!isVirtualDomNode(node)) {
@@ -289,11 +401,11 @@ const create$a = context => {
 
 const noEmptyAria = {
   __proto__: null,
-  create: create$a,
-  meta: meta$a
+  create: create$l,
+  meta: meta$l
 };
 
-const meta$9 = {
+const meta$k = {
   docs: {
     description: 'Disallow empty className values in virtual-dom nodes'
   },
@@ -302,7 +414,7 @@ const meta$9 = {
   },
   type: 'problem'
 };
-const create$9 = context => {
+const create$k = context => {
   return {
     ObjectExpression(node) {
       if (!isVirtualDomNode(node)) {
@@ -322,11 +434,11 @@ const create$9 = context => {
 
 const noEmptyClassName = {
   __proto__: null,
-  create: create$9,
-  meta: meta$9
+  create: create$k,
+  meta: meta$k
 };
 
-const meta$8 = {
+const meta$j = {
   docs: {
     description: 'Disallow inline event handlers in virtual-dom nodes'
   },
@@ -341,7 +453,7 @@ const isEventPropertyName = name => {
 const isInlineEventHandler = node => {
   return isStringLiteral(node) || isTemplateLiteralNode(node) || isArrowFunctionExpressionNode(node) || isFunctionExpressionNode(node);
 };
-const create$8 = context => {
+const create$j = context => {
   return {
     ObjectExpression(node) {
       if (!isVirtualDomNode(node)) {
@@ -366,11 +478,11 @@ const create$8 = context => {
 
 const noInlineEventHandlers = {
   __proto__: null,
-  create: create$8,
-  meta: meta$8
+  create: create$j,
+  meta: meta$j
 };
 
-const meta$7 = {
+const meta$i = {
   docs: {
     description: 'Disallow inline style attributes in virtual-dom nodes'
   },
@@ -379,7 +491,7 @@ const meta$7 = {
   },
   type: 'problem'
 };
-const create$7 = context => {
+const create$i = context => {
   return {
     ObjectExpression(node) {
       if (!isVirtualDomNode(node)) {
@@ -399,11 +511,59 @@ const create$7 = context => {
 
 const noInlineStyle = {
   __proto__: null,
-  create: create$7,
-  meta: meta$7
+  create: create$i,
+  meta: meta$i
 };
 
-const meta$6 = {
+const ignoredProperties$1 = new Set(['childCount', 'type']);
+const isOptionalExpression = node => {
+  return typeof node === 'object' && node !== null && ('type' in node && node.type === 'ChainExpression' || 'optional' in node && node.optional === true);
+};
+const isNullish = node => {
+  return isLiteralNode(node) && node.value === null || isIdentifierNode(node) && node.name === 'undefined' || isOptionalExpression(node);
+};
+const meta$h = {
+  docs: {
+    description: 'Disallow nullish virtual-dom attribute values'
+  },
+  messages: {
+    noNullishAttributeValue: 'Omit `{{name}}` instead of assigning a nullish value.'
+  },
+  type: 'problem'
+};
+const create$h = context => {
+  return {
+    ObjectExpression(node) {
+      if (!isVirtualDomNode(node)) {
+        return;
+      }
+      for (const property of node.properties) {
+        if (!isPropertyNode(property)) {
+          continue;
+        }
+        const name = getStaticPropertyName(property);
+        if (!name || ignoredProperties$1.has(name) || !isNullish(property.value)) {
+          continue;
+        }
+        context.report({
+          data: {
+            name
+          },
+          messageId: 'noNullishAttributeValue',
+          node: property.value
+        });
+      }
+    }
+  };
+};
+
+const noNullishAttributeValues = {
+  __proto__: null,
+  create: create$h,
+  meta: meta$h
+};
+
+const meta$g = {
   docs: {
     description: 'Disallow object-like attribute values in virtual-dom nodes'
   },
@@ -416,7 +576,7 @@ const ignoredProperties = new Set(['childCount', 'type']);
 const isObjectLikeAttributeValue = node => {
   return isObjectExpressionNode(node) || isArrayExpressionNode(node) || isArrowFunctionExpressionNode(node) || isFunctionExpressionNode(node);
 };
-const create$6 = context => {
+const create$g = context => {
   return {
     ObjectExpression(node) {
       if (!isVirtualDomNode(node)) {
@@ -441,11 +601,45 @@ const create$6 = context => {
 
 const noObjectAttributeValues = {
   __proto__: null,
-  create: create$6,
-  meta: meta$6
+  create: create$g,
+  meta: meta$g
 };
 
-const meta$5 = {
+const meta$f = {
+  docs: {
+    description: 'Disallow positive virtual-dom tabIndex values'
+  },
+  messages: {
+    noPositiveTabIndex: 'Use a `tabIndex` of 0 or -1 instead of a positive value.'
+  },
+  type: 'problem'
+};
+const create$f = context => {
+  return {
+    ObjectExpression(node) {
+      if (!isVirtualDomNode(node)) {
+        return;
+      }
+      const tabIndexProperty = getProperty(node, 'tabIndex');
+      const tabIndex = tabIndexProperty && getStaticNumberValue(tabIndexProperty.value);
+      if (!tabIndexProperty || tabIndex === undefined || tabIndex <= 0) {
+        return;
+      }
+      context.report({
+        messageId: 'noPositiveTabIndex',
+        node: tabIndexProperty.value
+      });
+    }
+  };
+};
+
+const noPositiveTabIndex = {
+  __proto__: null,
+  create: create$f,
+  meta: meta$f
+};
+
+const meta$e = {
   docs: {
     description: 'Disallow raw string children in virtual-dom arrays'
   },
@@ -457,7 +651,7 @@ const meta$5 = {
 const isVirtualDomArray = node => {
   return isArrayExpressionNode(node) && node.elements.some(element => isVirtualDomNode(element) || isTextCall(element));
 };
-const create$5 = context => {
+const create$e = context => {
   return {
     ArrayExpression(node) {
       if (!isVirtualDomArray(node)) {
@@ -478,16 +672,93 @@ const create$5 = context => {
 
 const noRawTextChildren = {
   __proto__: null,
-  create: create$5,
-  meta: meta$5
+  create: create$e,
+  meta: meta$e
 };
 
-const meta$4 = {
+const meta$d = {
+  docs: {
+    description: 'Require each virtual-dom event listener to call its dedicated handler'
+  },
+  messages: {
+    noSharedEventListenerHandler: 'Use the dedicated handler `{{name}}` as the first event listener parameter instead of `{{handler}}`.'
+  },
+  type: 'problem'
+};
+const create$d = context => {
+  return {
+    ObjectExpression(node) {
+      if (!isObjectExpressionNode(node)) {
+        return;
+      }
+      const nameProperty = getProperty(node, 'name');
+      const paramsProperty = getProperty(node, 'params');
+      if (!nameProperty || !paramsProperty || !isStringLiteral(nameProperty.value) || !isArrayExpressionNode(paramsProperty.value)) {
+        return;
+      }
+      const name = nameProperty.value.value;
+      const firstParameter = paramsProperty.value.elements[0];
+      if (!name.startsWith('handle') || !isStringLiteral(firstParameter) || firstParameter.value === name) {
+        return;
+      }
+      context.report({
+        data: {
+          handler: firstParameter.value,
+          name
+        },
+        messageId: 'noSharedEventListenerHandler',
+        node: firstParameter
+      });
+    }
+  };
+};
+
+const noSharedEventListenerHandlers = {
+  __proto__: null,
+  create: create$d,
+  meta: meta$d
+};
+
+const meta$c = {
+  docs: {
+    description: 'Prefer constants for single literal virtual-dom class names'
+  },
+  messages: {
+    preferClassNameConstant: 'Use a `ClassNames.*` constant instead of a literal `className`.'
+  },
+  type: 'suggestion'
+};
+const create$c = context => {
+  return {
+    ObjectExpression(node) {
+      if (!isVirtualDomNode(node)) {
+        return;
+      }
+      const classNameProperty = getProperty(node, 'className');
+      if (!classNameProperty || !isStringLiteral(classNameProperty.value) || classNameProperty.value.value === '' || /\s/.test(classNameProperty.value.value)) {
+        return;
+      }
+      context.report({
+        messageId: 'preferClassNameConstant',
+        node: classNameProperty.value
+      });
+    }
+  };
+};
+
+const preferClassNameConstants = {
+  __proto__: null,
+  create: create$c,
+  meta: meta$c
+};
+
+const meta$b = {
   docs: {
     description: 'Prefer virtual-dom constants over raw type, role, aria boolean, and tabIndex values'
   },
   messages: {
     preferAriaBooleanConstant: 'Use an ARIA boolean constant instead of a raw string.',
+    preferEventListenerConstant: 'Use a named event listener constant instead of a raw numeric id.',
     preferRoleConstant: 'Use `AriaRoles.*` instead of a raw role string.',
     preferTabIndexConstant: 'Use `TabIndex.*` instead of a raw tabIndex number.',
     preferTypeConstant: 'Use `VirtualDomElements.*` instead of a raw element type number.'
@@ -497,7 +768,7 @@ const meta$4 = {
 const isAriaBooleanProperty = name => {
   return /^aria[A-Z]/.test(name);
 };
-const create$4 = context => {
+const create$b = context => {
   return {
     ObjectExpression(node) {
       if (!isVirtualDomNode(node)) {
@@ -532,6 +803,13 @@ const create$4 = context => {
           });
           continue;
         }
+        if (/^on[A-Z]/.test(name) && isNumericLiteral(property.value)) {
+          context.report({
+            messageId: 'preferEventListenerConstant',
+            node: property.value
+          });
+          continue;
+        }
         if (isAriaBooleanProperty(name) && isStringLiteral(property.value) && (property.value.value === 'true' || property.value.value === 'false')) {
           context.report({
             messageId: 'preferAriaBooleanConstant',
@@ -545,11 +823,11 @@ const create$4 = context => {
 
 const preferConstants = {
   __proto__: null,
-  create: create$4,
-  meta: meta$4
+  create: create$b,
+  meta: meta$b
 };
 
-const meta$3 = {
+const meta$a = {
   docs: {
     description: 'Require Intl.DateTimeFormat instances to be created lazily'
   },
@@ -564,7 +842,7 @@ const isFunctionNode = node => {
 const isDateTimeFormat = node => {
   return node.type === 'MemberExpression' && !node.computed && node.object.type === 'Identifier' && node.object.name === 'Intl' && node.property.type === 'Identifier' && node.property.name === 'DateTimeFormat';
 };
-const create$3 = context => {
+const create$a = context => {
   const isCreatedLazily = node => {
     return context.sourceCode.getAncestors(node).some(isFunctionNode);
   };
@@ -585,8 +863,8 @@ const create$3 = context => {
 
 const preferLazyDateTimeFormat = {
   __proto__: null,
-  create: create$3,
-  meta: meta$3
+  create: create$a,
+  meta: meta$a
 };
 
 const isClassNameKey = node => {
@@ -634,7 +912,7 @@ const getParent = node => {
   }
   return undefined;
 };
-const meta$2 = {
+const meta$9 = {
   docs: {
     description: 'Prefer mergeClassNames for composing virtual-dom className values'
   },
@@ -643,7 +921,7 @@ const meta$2 = {
   },
   type: 'suggestion'
 };
-const create$2 = context => {
+const create$9 = context => {
   const reportNamespacedClassNameComposition = node => {
     if (!isManualClassNameConcatenation(node) || !hasClassNamesReference(node)) {
       return;
@@ -674,11 +952,11 @@ const create$2 = context => {
 
 const preferMergeClassNames = {
   __proto__: null,
-  create: create$2,
-  meta: meta$2
+  create: create$9,
+  meta: meta$9
 };
 
-const meta$1 = {
+const meta$8 = {
   docs: {
     description: 'Prefer destructuring state properties before use'
   },
@@ -705,7 +983,7 @@ const isWriteExpression = node => {
   }
   return parent.type === 'UnaryExpression' && parent.operator === 'delete' && parent.argument === node;
 };
-const create$1 = context => {
+const create$8 = context => {
   return {
     MemberExpression(node) {
       if (node.computed) {
@@ -733,11 +1011,218 @@ const create$1 = context => {
 
 const preferStateDestructuring = {
   __proto__: null,
-  create: create$1,
-  meta: meta$1
+  create: create$8,
+  meta: meta$8
 };
 
-const meta = {
+const meta$7 = {
+  docs: {
+    description: 'Require event listener options for handlers with specific browser event behavior'
+  },
+  messages: {
+    requirePreventDefault: '`{{name}}` event listeners must set `preventDefault` to `true`.'
+  },
+  type: 'problem'
+};
+const listenersRequiringPreventDefault = new Set(['handleDragOver', 'handleDrop']);
+const create$7 = context => {
+  return {
+    ObjectExpression(node) {
+      if (!isObjectExpressionNode(node) || !getProperty(node, 'params')) {
+        return;
+      }
+      const nameProperty = getProperty(node, 'name');
+      if (!nameProperty || !isStringLiteral(nameProperty.value) || !listenersRequiringPreventDefault.has(nameProperty.value.value)) {
+        return;
+      }
+      const preventDefaultProperty = getProperty(node, 'preventDefault');
+      if (preventDefaultProperty && isLiteralNode(preventDefaultProperty.value) && preventDefaultProperty.value.value === true) {
+        return;
+      }
+      context.report({
+        data: {
+          name: nameProperty.value.value
+        },
+        messageId: 'requirePreventDefault',
+        node: preventDefaultProperty ? preventDefaultProperty.value : nameProperty
+      });
+    }
+  };
+};
+
+const requireEventListenerOptions = {
+  __proto__: null,
+  create: create$7,
+  meta: meta$7
+};
+
+const meta$6 = {
+  docs: {
+    description: 'Require alt text on virtual-dom image nodes'
+  },
+  messages: {
+    requireImageAlt: 'Add an `alt` attribute to this virtual-dom image.'
+  },
+  type: 'problem'
+};
+const create$6 = context => {
+  return {
+    ObjectExpression(node) {
+      if (!isVirtualDomNode(node)) {
+        return;
+      }
+      const typeProperty = getProperty(node, 'type');
+      if (!typeProperty || getVirtualDomElementName(typeProperty.value) !== 'Img' || getProperty(node, 'alt')) {
+        return;
+      }
+      context.report({
+        messageId: 'requireImageAlt',
+        node
+      });
+    }
+  };
+};
+
+const requireImageAlt = {
+  __proto__: null,
+  create: create$6,
+  meta: meta$6
+};
+
+const meta$5 = {
+  docs: {
+    description: 'Require secure attributes on virtual-dom links'
+  },
+  messages: {
+    secureLinkRel: 'Set `rel` to `noopener noreferrer` on virtual-dom links.',
+    secureLinkTarget: 'Set `target` to `_blank` on virtual-dom links.'
+  },
+  type: 'problem'
+};
+const hasStringPropertyValue = (node, name, value) => {
+  const property = getProperty(node, name);
+  return Boolean(property && isStringLiteral(property.value) && property.value.value === value);
+};
+const create$5 = context => {
+  return {
+    ObjectExpression(node) {
+      if (!isVirtualDomNode(node)) {
+        return;
+      }
+      const typeProperty = getProperty(node, 'type');
+      const hrefProperty = getProperty(node, 'href');
+      if (!typeProperty || !hrefProperty || !isMemberExpressionWithProperty(typeProperty.value, 'A')) {
+        return;
+      }
+      if (!hasStringPropertyValue(node, 'target', '_blank')) {
+        context.report({
+          messageId: 'secureLinkTarget',
+          node
+        });
+      }
+      if (!hasStringPropertyValue(node, 'rel', 'noopener noreferrer')) {
+        context.report({
+          messageId: 'secureLinkRel',
+          node
+        });
+      }
+    }
+  };
+};
+
+const secureLinks = {
+  __proto__: null,
+  create: create$5,
+  meta: meta$5
+};
+
+const validAriaProperties = new Set(['ariaActivedescendant', 'ariaAtomic', 'ariaAutoComplete', 'ariaBrailleLabel', 'ariaBrailleRoleDescription', 'ariaBusy', 'ariaChecked', 'ariaColCount', 'ariaColIndex', 'ariaColIndexText', 'ariaColSpan', 'ariaControls', 'ariaCurrent', 'ariaDescribedBy', 'ariaDescription', 'ariaDetails', 'ariaDisabled', 'ariaErrorMessage', 'ariaExpanded', 'ariaFlowTo', 'ariaHasPopup', 'ariaHidden', 'ariaInvalid', 'ariaKeyShortcuts', 'ariaLabel', 'ariaLabelledBy', 'ariaLevel', 'ariaLive', 'ariaModal', 'ariaMultiLine', 'ariaMultiSelectable', 'ariaOrientation', 'ariaOwns', 'ariaPlaceholder', 'ariaPosInSet', 'ariaPressed', 'ariaReadOnly', 'ariaRelevant', 'ariaRequired', 'ariaRoleDescription', 'ariaRowCount', 'ariaRowIndex', 'ariaRowIndexText', 'ariaRowSpan', 'ariaSelected', 'ariaSetSize', 'ariaSort', 'ariaValueMax', 'ariaValueMin', 'ariaValueNow', 'ariaValueText']);
+const meta$4 = {
+  docs: {
+    description: 'Validate virtual-dom ARIA property names'
+  },
+  messages: {
+    validAriaProperty: '`{{name}}` is not a valid virtual-dom ARIA property.'
+  },
+  type: 'problem'
+};
+const create$4 = context => {
+  return {
+    ObjectExpression(node) {
+      if (!isVirtualDomNode(node)) {
+        return;
+      }
+      for (const property of node.properties) {
+        if (!isPropertyNode(property)) {
+          continue;
+        }
+        const name = getStaticPropertyName(property);
+        if (!name?.startsWith('aria') || validAriaProperties.has(name)) {
+          continue;
+        }
+        context.report({
+          data: {
+            name
+          },
+          messageId: 'validAriaProperty',
+          node: property
+        });
+      }
+    }
+  };
+};
+
+const validAriaProperties$1 = {
+  __proto__: null,
+  create: create$4,
+  meta: meta$4
+};
+
+const allowedValues = new Map([['ariaAtomic', new Set(['false', 'true'])], ['ariaAutoComplete', new Set(['both', 'inline', 'list', 'none'])], ['ariaBusy', new Set(['false', 'true'])], ['ariaChecked', new Set(['false', 'mixed', 'true'])], ['ariaCurrent', new Set(['date', 'false', 'location', 'page', 'step', 'time', 'true'])], ['ariaDisabled', new Set(['false', 'true'])], ['ariaExpanded', new Set(['false', 'true'])], ['ariaHasPopup', new Set(['dialog', 'false', 'grid', 'listbox', 'menu', 'tree', 'true'])], ['ariaHidden', new Set(['false', 'true'])], ['ariaInvalid', new Set(['false', 'grammar', 'spelling', 'true'])], ['ariaLive', new Set(['assertive', 'off', 'polite'])], ['ariaModal', new Set(['false', 'true'])], ['ariaMultiLine', new Set(['false', 'true'])], ['ariaMultiSelectable', new Set(['false', 'true'])], ['ariaOrientation', new Set(['horizontal', 'undefined', 'vertical'])], ['ariaPressed', new Set(['false', 'mixed', 'true'])], ['ariaReadOnly', new Set(['false', 'true'])], ['ariaRelevant', new Set(['additions', 'additions removals', 'additions text', 'all', 'removals', 'removals additions', 'removals text', 'text', 'text additions', 'text removals'])], ['ariaRequired', new Set(['false', 'true'])], ['ariaSelected', new Set(['false', 'true'])], ['ariaSort', new Set(['ascending', 'descending', 'none', 'other'])]]);
+const meta$3 = {
+  docs: {
+    description: 'Validate literal virtual-dom ARIA values'
+  },
+  messages: {
+    validAriaValue: '`{{value}}` is not a valid value for `{{name}}`.'
+  },
+  type: 'problem'
+};
+const create$3 = context => {
+  return {
+    ObjectExpression(node) {
+      if (!isVirtualDomNode(node)) {
+        return;
+      }
+      for (const property of node.properties) {
+        if (!isPropertyNode(property)) {
+          continue;
+        }
+        const name = getStaticPropertyName(property);
+        const values = name && allowedValues.get(name);
+        if (!name || !values || !isStringLiteral(property.value) || values.has(property.value.value)) {
+          continue;
+        }
+        context.report({
+          data: {
+            name,
+            value: property.value.value
+          },
+          messageId: 'validAriaValue',
+          node: property.value
+        });
+      }
+    }
+  };
+};
+
+const validAriaValues = {
+  __proto__: null,
+  create: create$3,
+  meta: meta$3
+};
+
+const meta$2 = {
   docs: {
     description: 'Validate statically analyzable virtual-dom childCount values'
   },
@@ -812,7 +1297,7 @@ const hasImpossibleChildCount = (elements, index) => {
   }
   return false;
 };
-const create = context => {
+const create$2 = context => {
   return {
     ArrayExpression(node) {
       if (!isArrayExpressionNode(node) || !node.elements.some(isVirtualDomNode) || !node.elements.every(isAnalyzableVirtualDomElement)) {
@@ -841,6 +1326,103 @@ const create = context => {
 };
 
 const validChildCount = {
+  __proto__: null,
+  create: create$2,
+  meta: meta$2
+};
+
+const supportedEventProperties = new Set(['onBeforeInput', 'onBlur', 'onChange', 'onClick', 'onContextMenu', 'onDblClick', 'onDragEnd', 'onDragEnter', 'onDragLeave', 'onDragOver', 'onDragStart', 'onDrop', 'onFocus', 'onFocusIn', 'onFocusOut', 'onInput', 'onKeyDown', 'onKeyUp', 'onMouseDown', 'onMouseMove', 'onMouseOut', 'onMouseOver', 'onMouseUp', 'onPointerDown', 'onPointerMove', 'onPointerOut', 'onPointerOver', 'onScroll', 'onSelectionChange', 'onSubmit', 'onWheel']);
+const meta$1 = {
+  docs: {
+    description: 'Require virtual-dom event properties supported by the renderer'
+  },
+  messages: {
+    validEventProperty: '`{{name}}` is not a supported virtual-dom event property.'
+  },
+  type: 'problem'
+};
+const create$1 = context => {
+  return {
+    ObjectExpression(node) {
+      if (!isVirtualDomNode(node)) {
+        return;
+      }
+      for (const property of node.properties) {
+        if (!isPropertyNode(property)) {
+          continue;
+        }
+        const name = getStaticPropertyName(property);
+        if (!name?.startsWith('on') || supportedEventProperties.has(name)) {
+          continue;
+        }
+        context.report({
+          data: {
+            name
+          },
+          messageId: 'validEventProperty',
+          node: property
+        });
+      }
+    }
+  };
+};
+
+const validEventProperties = {
+  __proto__: null,
+  create: create$1,
+  meta: meta$1
+};
+
+const voidElements = new Set(['Br', 'Col', 'Hr', 'Img', 'Input']);
+const meta = {
+  docs: {
+    description: 'Require canonical virtual-dom node shapes'
+  },
+  messages: {
+    elementTextProperty: 'Use a `text(...)` child instead of a `text` property on an element node.',
+    missingChildCount: 'Add an explicit `childCount` to this virtual-dom node.',
+    voidElementChildren: '`VirtualDomElements.{{name}}` must have a `childCount` of 0.'
+  },
+  type: 'problem'
+};
+const create = context => {
+  return {
+    ObjectExpression(node) {
+      if (!isObjectExpressionNode(node)) {
+        return;
+      }
+      const typeProperty = getProperty(node, 'type');
+      const elementName = typeProperty && getVirtualDomElementName(typeProperty.value);
+      if (!typeProperty || !elementName) {
+        return;
+      }
+      const childCountProperty = getProperty(node, 'childCount');
+      if (!childCountProperty) {
+        context.report({
+          messageId: 'missingChildCount',
+          node
+        });
+      } else if (voidElements.has(elementName) && getStaticNumberValue(childCountProperty.value) !== 0) {
+        context.report({
+          data: {
+            name: elementName
+          },
+          messageId: 'voidElementChildren',
+          node: childCountProperty
+        });
+      }
+      const textProperty = getProperty(node, 'text');
+      if (textProperty && elementName !== 'Text') {
+        context.report({
+          messageId: 'elementTextProperty',
+          node: textProperty
+        });
+      }
+    }
+  };
+};
+
+const validNodeShape = {
   __proto__: null,
   create,
   meta
@@ -853,19 +1435,32 @@ const plugin = {
     version: '0.0.1'
   },
   rules: {
+    'accessible-control-name': accessibleControlName,
     'clickable-div-needs-role': clickableDivNeedsRole,
     'hoist-static-nodes': hoistStaticNodes,
+    'no-conditional-spread': noConditionalSpread,
     'no-empty-aria': noEmptyAria,
     'no-empty-class-name': noEmptyClassName,
     'no-inline-event-handlers': noInlineEventHandlers,
     'no-inline-style': noInlineStyle,
+    'no-nullish-attribute-values': noNullishAttributeValues,
     'no-object-attribute-values': noObjectAttributeValues,
+    'no-positive-tab-index': noPositiveTabIndex,
     'no-raw-text-children': noRawTextChildren,
+    'no-shared-event-listener-handlers': noSharedEventListenerHandlers,
+    'prefer-class-name-constants': preferClassNameConstants,
     'prefer-constants': preferConstants,
     'prefer-lazy-date-time-format': preferLazyDateTimeFormat,
     'prefer-merge-class-names': preferMergeClassNames,
     'prefer-state-destructuring': preferStateDestructuring,
-    'valid-child-count': validChildCount
+    'require-event-listener-options': requireEventListenerOptions,
+    'require-image-alt': requireImageAlt,
+    'secure-links': secureLinks,
+    'valid-aria-properties': validAriaProperties$1,
+    'valid-aria-values': validAriaValues,
+    'valid-child-count': validChildCount,
+    'valid-event-properties': validEventProperties,
+    'valid-node-shape': validNodeShape
   }
 };
 const recommended = [{
@@ -876,16 +1471,20 @@ const recommended = [{
   rules: {
     'virtual-dom/clickable-div-needs-role': 'error',
     'virtual-dom/hoist-static-nodes': 'error',
+    'virtual-dom/no-conditional-spread': 'error',
     'virtual-dom/no-empty-aria': 'error',
     'virtual-dom/no-empty-class-name': 'error',
     'virtual-dom/no-inline-event-handlers': 'error',
     'virtual-dom/no-inline-style': 'error',
     'virtual-dom/no-object-attribute-values': 'error',
     'virtual-dom/no-raw-text-children': 'error',
+    'virtual-dom/no-shared-event-listener-handlers': 'error',
     'virtual-dom/prefer-constants': 'error',
     'virtual-dom/prefer-lazy-date-time-format': 'error',
     'virtual-dom/prefer-merge-class-names': 'error',
     'virtual-dom/prefer-state-destructuring': 'error',
+    'virtual-dom/require-event-listener-options': 'error',
+    'virtual-dom/secure-links': 'error',
     'virtual-dom/valid-child-count': 'error'
   }
 }, {
@@ -894,5 +1493,19 @@ const recommended = [{
     'virtual-dom/hoist-static-nodes': 'off'
   }
 }];
+const strict = [...recommended, {
+  files: ['**/*.{js,mjs,cjs,ts,mts,cts}'],
+  rules: {
+    'virtual-dom/accessible-control-name': 'error',
+    'virtual-dom/no-nullish-attribute-values': 'error',
+    'virtual-dom/no-positive-tab-index': 'error',
+    'virtual-dom/prefer-class-name-constants': 'error',
+    'virtual-dom/require-image-alt': 'error',
+    'virtual-dom/valid-aria-properties': 'error',
+    'virtual-dom/valid-aria-values': 'error',
+    'virtual-dom/valid-event-properties': 'error',
+    'virtual-dom/valid-node-shape': 'error'
+  }
+}];
 
-export { recommended as default };
+export { recommended as default, strict };

package/package.json

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