@shrpne/eslint-plugin-vue-extra 0.1.0 → 0.1.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shrpne/eslint-plugin-vue-extra",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "Extra ESLint rules for Vue projects",
   "license": "MIT",
   "keywords": [

package/rules/prefer-optional-boolean-prop.js

@@ -27,6 +27,125 @@ function isDefinePropsCall(node) {
     );
 }
 
+function isDefineEmitsCall(node) {
+    return (
+        node &&
+        node.type === 'CallExpression' &&
+        node.callee &&
+        node.callee.type === 'Identifier' &&
+        node.callee.name === 'defineEmits'
+    );
+}
+
+function getPropNameFromUpdateEventName(eventName) {
+    if (typeof eventName !== 'string') return null;
+    if (!eventName.startsWith('update:')) return null;
+
+    const propName = eventName.slice('update:'.length);
+    return propName || null;
+}
+
+function addModelPropNameFromEventName(set, eventName) {
+    const propName = getPropNameFromUpdateEventName(eventName);
+    if (propName) {
+        set.add(propName);
+    }
+}
+
+function collectModelPropNamesFromTypeNode(typeNode, modelPropNames) {
+    if (!typeNode || typeNode.type !== 'TSTypeLiteral') return;
+
+    for (const member of typeNode.members) {
+        if (member.type === 'TSCallSignatureDeclaration') {
+            const firstParam = member.params && member.params[0];
+            if (
+                firstParam &&
+                firstParam.type === 'Identifier' &&
+                firstParam.typeAnnotation &&
+                firstParam.typeAnnotation.typeAnnotation &&
+                firstParam.typeAnnotation.typeAnnotation.type === 'TSLiteralType' &&
+                firstParam.typeAnnotation.typeAnnotation.literal &&
+                firstParam.typeAnnotation.typeAnnotation.literal.type === 'Literal' &&
+                typeof firstParam.typeAnnotation.typeAnnotation.literal.value === 'string'
+            ) {
+                addModelPropNameFromEventName(
+                    modelPropNames,
+                    firstParam.typeAnnotation.typeAnnotation.literal.value
+                );
+            }
+            continue;
+        }
+
+        if (member.type === 'TSPropertySignature' && member.key) {
+            if (member.key.type === 'Literal' && typeof member.key.value === 'string') {
+                addModelPropNameFromEventName(modelPropNames, member.key.value);
+            }
+        }
+    }
+}
+
+function collectModelPropNamesFromDefineEmitsCall(node, modelPropNames) {
+    if (!isDefineEmitsCall(node)) return;
+
+    const firstArg = node.arguments && node.arguments[0];
+    if (firstArg && firstArg.type === 'ArrayExpression') {
+        for (const element of firstArg.elements) {
+            if (element && element.type === 'Literal' && typeof element.value === 'string') {
+                addModelPropNameFromEventName(modelPropNames, element.value);
+            }
+        }
+    }
+
+    if (firstArg && firstArg.type === 'ObjectExpression') {
+        for (const prop of firstArg.properties) {
+            if (prop.type !== 'Property' || prop.computed || !prop.key) continue;
+            if (prop.key.type === 'Literal' && typeof prop.key.value === 'string') {
+                addModelPropNameFromEventName(modelPropNames, prop.key.value);
+            }
+        }
+    }
+
+    const typeArgs = node.typeArguments;
+    if (typeArgs && typeArgs.params && typeArgs.params.length > 0) {
+        collectModelPropNamesFromTypeNode(typeArgs.params[0], modelPropNames);
+    }
+}
+
+function collectModelPropNamesFromAst(rootNode) {
+    const modelPropNames = new Set(['modelValue']);
+    const visited = new WeakSet();
+
+    function visit(node) {
+        if (!node || typeof node !== 'object') return;
+        if (visited.has(node)) return;
+        visited.add(node);
+
+        if (node.type === 'CallExpression') {
+            collectModelPropNamesFromDefineEmitsCall(node, modelPropNames);
+        }
+
+        for (const value of Object.values(node)) {
+            if (!value) continue;
+
+            if (Array.isArray(value)) {
+                for (const item of value) {
+                    if (item && typeof item.type === 'string') {
+                        visit(item);
+                    }
+                }
+                continue;
+            }
+
+            if (value && typeof value.type === 'string') {
+                visit(value);
+            }
+        }
+    }
+
+    visit(rootNode);
+    return modelPropNames;
+}
+
 function isBooleanLikeType(type) {
     if (!type) return false;
 
@@ -199,6 +318,7 @@ const preferOptionalBooleanProp = {
         const services = context.sourceCode.parserServices;
         const hasTypeInfo = !!(services && services.program && services.esTreeNodeToTSNodeMap);
         const fixReferencedTypes = !!(context.options[0] && context.options[0].fixReferencedTypes);
+        const modelPropNames = collectModelPropNamesFromAst(context.sourceCode.ast);
 
         const programTsNode = hasTypeInfo
             ? services.esTreeNodeToTSNodeMap.get(context.sourceCode.ast)
@@ -226,6 +346,7 @@ const preferOptionalBooleanProp = {
                 const booleanDefaultsMap = getBooleanDefaultsMap(secondArg);
 
                 for (const [name, metadata] of propMetadataMap.entries()) {
+                    if (modelPropNames.has(name)) continue;
                     if (!metadata.isBooleanLike) continue;
                     if (metadata.isOptional) continue;