eslint-plugin-vue
Version:
Official ESLint plugin for Vue.js
169 lines (166 loc) • 6.1 kB
JavaScript
'use strict';
const require_runtime = require('../_virtual/_rolldown/runtime.js');
const require_index = require('../utils/index.js');
//#region lib/rules/valid-v-model.js
/**
* @author Toru Nagashima
* @copyright 2017 Toru Nagashima. All rights reserved.
* See LICENSE file in root directory for full license.
*/
var require_valid_v_model = /* @__PURE__ */ require_runtime.__commonJSMin(((exports, module) => {
const utils = require_index.default;
const VALID_MODIFIERS = new Set([
"lazy",
"number",
"trim"
]);
/**
* Check whether the given node is valid or not.
* @param {VElement} node The element node to check.
* @returns {boolean} `true` if the node is valid.
*/
function isValidElement(node) {
const name = node.name;
return name === "input" || name === "select" || name === "textarea" || name !== "keep-alive" && name !== "slot" && name !== "transition" && name !== "transition-group" && utils.isCustomComponent(node);
}
/**
* Check whether the given node is a MemberExpression containing an optional chaining.
* e.g.
* - `a?.b`
* - `a?.b.c`
* @param {ASTNode} node The node to check.
* @returns {boolean} `true` if the node is a MemberExpression containing an optional chaining.
*/
function isOptionalChainingMemberExpression(node) {
return node.type === "ChainExpression" && node.expression.type === "MemberExpression";
}
/**
* Check whether the given node can be LHS (left-hand side).
* @param {ASTNode} node The node to check.
* @returns {boolean} `true` if the node can be LHS.
*/
function isLhs(node) {
if (node.type === "TSAsExpression" || node.type === "TSNonNullExpression") return isLhs(node.expression);
return node.type === "Identifier" || node.type === "MemberExpression";
}
/**
* Check whether the given node is a MemberExpression of a possibly null object.
* e.g.
* - `(a?.b).c`
* - `(null).foo`
* @param {ASTNode} node The node to check.
* @returns {boolean} `true` if the node is a MemberExpression of a possibly null object.
*/
function maybeNullObjectMemberExpression(node) {
if (node.type !== "MemberExpression") return false;
const { object } = node;
if (object.type === "ChainExpression") return true;
if (object.type === "Literal" && object.value === null && !object.bigint) return true;
if (object.type === "MemberExpression") return maybeNullObjectMemberExpression(object);
return false;
}
/**
* Get the variable by names.
* @param {string} name The variable name to find.
* @param {VElement} leafNode The node to look up.
* @returns {VVariable|null} The found variable or null.
*/
function getVariable(name, leafNode) {
let node = leafNode;
while (node != null) {
const variables = node.variables;
const variable = variables && variables.find((v) => v.id.name === name);
if (variable != null) return variable;
if (node.parent.type === "VDocumentFragment") break;
node = node.parent;
}
return null;
}
/** @type {RuleModule} */
module.exports = {
meta: {
type: "problem",
docs: {
description: "enforce valid `v-model` directives",
categories: ["vue3-essential", "vue2-essential"],
url: "https://eslint.vuejs.org/rules/valid-v-model.html"
},
fixable: null,
schema: [],
messages: {
unexpectedInvalidElement: "'v-model' directives aren't supported on <{{name}}> elements.",
unexpectedInputFile: "'v-model' directives don't support 'file' input type.",
unexpectedArgument: "'v-model' directives require no argument.",
unexpectedModifier: "'v-model' directives don't support the modifier '{{name}}'.",
missingValue: "'v-model' directives require that attribute value.",
unexpectedOptionalChaining: "Optional chaining cannot appear in 'v-model' directives.",
unexpectedNonLhsExpression: "'v-model' directives require the attribute value which is valid as LHS.",
unexpectedNullObject: "'v-model' directive has potential null object property access.",
unexpectedUpdateIterationVariable: "'v-model' directives cannot update the iteration variable '{{varName}}' itself."
}
},
create(context) {
return utils.defineTemplateBodyVisitor(context, { "VAttribute[directive=true][key.name.name='model']"(node) {
const element = node.parent.parent;
const name = element.name;
if (!isValidElement(element)) context.report({
node,
messageId: "unexpectedInvalidElement",
data: { name }
});
if (name === "input" && utils.hasAttribute(element, "type", "file")) context.report({
node,
messageId: "unexpectedInputFile"
});
if (!utils.isCustomComponent(element)) {
if (node.key.argument) context.report({
node: node.key.argument,
messageId: "unexpectedArgument"
});
for (const modifier of node.key.modifiers) if (!VALID_MODIFIERS.has(modifier.name)) context.report({
node: modifier,
messageId: "unexpectedModifier",
data: { name: modifier.name }
});
}
if (!node.value || utils.isEmptyValueDirective(node, context)) {
context.report({
node,
messageId: "missingValue"
});
return;
}
const expression = node.value.expression;
if (!expression) return;
if (isOptionalChainingMemberExpression(expression)) context.report({
node: expression,
messageId: "unexpectedOptionalChaining"
});
else if (!isLhs(expression)) context.report({
node: expression,
messageId: "unexpectedNonLhsExpression"
});
else if (maybeNullObjectMemberExpression(expression)) context.report({
node: expression,
messageId: "unexpectedNullObject"
});
for (const reference of node.value.references) {
const id = reference.id;
if (id.parent.type !== "VExpressionContainer") continue;
if (getVariable(id.name, element) != null) context.report({
node: expression,
messageId: "unexpectedUpdateIterationVariable",
data: { varName: id.name }
});
}
} });
}
};
}));
//#endregion
Object.defineProperty(exports, 'default', {
enumerable: true,
get: function () {
return require_valid_v_model();
}
});