routie dev init since i didn't adhere to any proper guidance up until now
This commit is contained in:
Generated
Vendored
+436
@@ -0,0 +1,436 @@
|
||||
'use strict';
|
||||
|
||||
const require_runtime = require('../_virtual/_rolldown/runtime.js');
|
||||
const require_index = require('../utils/index.js');
|
||||
|
||||
//#region lib/rules/no-use-computed-property-like-method.js
|
||||
/**
|
||||
* @author tyankatsu <https://github.com/tyankatsu0105>
|
||||
* See LICENSE file in root directory for full license.
|
||||
*/
|
||||
var require_no_use_computed_property_like_method = /* @__PURE__ */ require_runtime.__commonJSMin(((exports, module) => {
|
||||
const eslintUtils = require("@eslint-community/eslint-utils");
|
||||
const utils = require_index.default;
|
||||
/**
|
||||
* @typedef {import('eslint').Scope.Scope} Scope
|
||||
* @typedef {import('../utils').ComponentObjectPropertyData} ComponentObjectPropertyData
|
||||
* @typedef {import('../utils').GroupName} GroupName
|
||||
*/
|
||||
/**
|
||||
* @typedef {object} CallMember
|
||||
* @property {string} name
|
||||
* @property {CallExpression} node
|
||||
*/
|
||||
/** @type {Set<GroupName>} */
|
||||
const GROUPS = new Set([
|
||||
"data",
|
||||
"props",
|
||||
"computed",
|
||||
"methods"
|
||||
]);
|
||||
const NATIVE_NOT_FUNCTION_TYPES = new Set([
|
||||
"String",
|
||||
"Number",
|
||||
"BigInt",
|
||||
"Boolean",
|
||||
"Object",
|
||||
"Array",
|
||||
"Symbol"
|
||||
]);
|
||||
/**
|
||||
* @param {RuleContext} context
|
||||
* @param {Expression} node
|
||||
* @returns {Set<Expression>}
|
||||
*/
|
||||
function resolvedExpressions(context, node) {
|
||||
/** @type {Map<Expression, Set<Expression>>} */
|
||||
const resolvedMap = /* @__PURE__ */ new Map();
|
||||
return resolvedExpressionsInternal(node);
|
||||
/**
|
||||
* @param {Expression} node
|
||||
* @returns {Set<Expression>}
|
||||
*/
|
||||
function resolvedExpressionsInternal(node) {
|
||||
let resolvedSet = resolvedMap.get(node);
|
||||
if (!resolvedSet) {
|
||||
resolvedSet = /* @__PURE__ */ new Set();
|
||||
resolvedMap.set(node, resolvedSet);
|
||||
for (const e of extractResolvedExpressions(node)) resolvedSet.add(e);
|
||||
}
|
||||
if (resolvedSet.size === 0) resolvedSet.add(node);
|
||||
return resolvedSet;
|
||||
}
|
||||
/**
|
||||
* @param {Expression} node
|
||||
* @returns {Iterable<Expression>}
|
||||
*/
|
||||
function* extractResolvedExpressions(node) {
|
||||
switch (node.type) {
|
||||
case "Identifier": {
|
||||
const variable = utils.findVariableByIdentifier(context, node);
|
||||
if (variable) for (const ref of variable.references) {
|
||||
const id = ref.identifier;
|
||||
if (id.parent.type === "VariableDeclarator") {
|
||||
if (id.parent.id === id && id.parent.init) yield* resolvedExpressionsInternal(id.parent.init);
|
||||
} else if (id.parent.type === "AssignmentExpression" && id.parent.left === id) yield* resolvedExpressionsInternal(id.parent.right);
|
||||
}
|
||||
break;
|
||||
}
|
||||
case "ConditionalExpression":
|
||||
yield* resolvedExpressionsInternal(node.consequent);
|
||||
yield* resolvedExpressionsInternal(node.alternate);
|
||||
break;
|
||||
case "LogicalExpression":
|
||||
yield* resolvedExpressionsInternal(node.left);
|
||||
yield* resolvedExpressionsInternal(node.right);
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
/**
|
||||
* Get type of props item.
|
||||
* Can't consider array props like: props: {propsA: [String, Number, Function]}
|
||||
* @param {RuleContext} context
|
||||
* @param {ComponentObjectPropertyData} prop
|
||||
* @return {string[] | null}
|
||||
*
|
||||
* @example
|
||||
* props: {
|
||||
* propA: String, // => String
|
||||
* propB: {
|
||||
* type: Number // => Number
|
||||
* },
|
||||
* }
|
||||
*/
|
||||
function getComponentPropsTypes(context, prop) {
|
||||
const result = [];
|
||||
for (const expr of resolvedExpressions(context, prop.property.value)) {
|
||||
const types = getComponentPropsTypesFromExpression(expr);
|
||||
if (types == null) return null;
|
||||
result.push(...types);
|
||||
}
|
||||
return result;
|
||||
/**
|
||||
* @param {Expression} expr
|
||||
*/
|
||||
function getComponentPropsTypesFromExpression(expr) {
|
||||
let typeExprs;
|
||||
/**
|
||||
* Check object props `props: { objectProps: {...} }`
|
||||
*/
|
||||
if (expr.type === "ObjectExpression") {
|
||||
const type = utils.findProperty(expr, "type");
|
||||
if (type == null) return null;
|
||||
typeExprs = resolvedExpressions(context, type.value);
|
||||
} else typeExprs = [expr];
|
||||
const result = [];
|
||||
for (const typeExpr of typeExprs) {
|
||||
const types = getComponentPropsTypesFromTypeExpression(typeExpr);
|
||||
if (types == null) return null;
|
||||
result.push(...types);
|
||||
}
|
||||
return result;
|
||||
}
|
||||
/**
|
||||
* @param {Expression} typeExpr
|
||||
*/
|
||||
function getComponentPropsTypesFromTypeExpression(typeExpr) {
|
||||
if (typeExpr.type === "Identifier") return [typeExpr.name];
|
||||
if (typeExpr.type === "ArrayExpression") {
|
||||
const types = [];
|
||||
for (const element of typeExpr.elements) {
|
||||
if (!element) continue;
|
||||
if (element.type === "SpreadElement") return null;
|
||||
for (const elementExpr of resolvedExpressions(context, element)) {
|
||||
if (elementExpr.type !== "Identifier") return null;
|
||||
types.push(elementExpr.name);
|
||||
}
|
||||
}
|
||||
return types;
|
||||
}
|
||||
return null;
|
||||
}
|
||||
}
|
||||
/**
|
||||
* Check whether given expression may be a function.
|
||||
* @param {RuleContext} context
|
||||
* @param {Expression} node
|
||||
* @returns {boolean}
|
||||
*/
|
||||
function maybeFunction(context, node) {
|
||||
for (const expr of resolvedExpressions(context, node)) {
|
||||
if (expr.type === "ObjectExpression" || expr.type === "ArrayExpression" || expr.type === "Literal" || expr.type === "TemplateLiteral" || expr.type === "BinaryExpression" || expr.type === "UnaryExpression" || expr.type === "UpdateExpression") continue;
|
||||
if (expr.type === "ConditionalExpression" && !maybeFunction(context, expr.consequent) && !maybeFunction(context, expr.alternate)) continue;
|
||||
const evaluated = eslintUtils.getStaticValue(expr, utils.getScope(context, expr));
|
||||
if (!evaluated) return true;
|
||||
if (typeof evaluated.value === "function") return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
var FunctionData = class {
|
||||
/**
|
||||
* @param {string} name
|
||||
* @param {'methods' | 'computed'} kind
|
||||
* @param {FunctionExpression | ArrowFunctionExpression} node
|
||||
* @param {RuleContext} context
|
||||
*/
|
||||
constructor(name, kind, node, context) {
|
||||
this.context = context;
|
||||
this.name = name;
|
||||
this.kind = kind;
|
||||
this.node = node;
|
||||
/** @type {(Expression | null)[]} */
|
||||
this.returnValues = [];
|
||||
/** @type {boolean | null} */
|
||||
this.cacheMaybeReturnFunction = null;
|
||||
}
|
||||
/**
|
||||
* @param {Expression | null} node
|
||||
*/
|
||||
addReturnValue(node) {
|
||||
this.returnValues.push(node);
|
||||
}
|
||||
/**
|
||||
* @param {ComponentStack} component
|
||||
*/
|
||||
maybeReturnFunction(component) {
|
||||
if (this.cacheMaybeReturnFunction != null) return this.cacheMaybeReturnFunction;
|
||||
this.cacheMaybeReturnFunction = true;
|
||||
return this.cacheMaybeReturnFunction = this.returnValues.some((returnValue) => returnValue && component.maybeFunctionExpression(returnValue));
|
||||
}
|
||||
};
|
||||
/** Component information class. */
|
||||
var ComponentStack = class {
|
||||
/**
|
||||
* @param {ObjectExpression} node
|
||||
* @param {RuleContext} context
|
||||
* @param {ComponentStack | null} upper
|
||||
*/
|
||||
constructor(node, context, upper) {
|
||||
this.node = node;
|
||||
this.context = context;
|
||||
/** Upper scope component */
|
||||
this.upper = upper;
|
||||
/** @type {Map<string, boolean>} */
|
||||
const maybeFunctions = /* @__PURE__ */ new Map();
|
||||
/** @type {FunctionData[]} */
|
||||
const functions = [];
|
||||
for (const property of utils.iterateProperties(node, GROUPS)) {
|
||||
if (property.type === "array") continue;
|
||||
switch (property.groupName) {
|
||||
case "data":
|
||||
maybeFunctions.set(property.name, maybeFunction(context, property.property.value));
|
||||
break;
|
||||
case "props": {
|
||||
const types = getComponentPropsTypes(context, property);
|
||||
maybeFunctions.set(property.name, !types || types.some((type) => !NATIVE_NOT_FUNCTION_TYPES.has(type)));
|
||||
break;
|
||||
}
|
||||
case "computed": {
|
||||
let value = property.property.value;
|
||||
if (value.type === "ObjectExpression") {
|
||||
const getProp = utils.findProperty(value, "get");
|
||||
if (getProp) value = getProp.value;
|
||||
}
|
||||
processFunction(property.name, value, "computed");
|
||||
break;
|
||||
}
|
||||
case "methods": {
|
||||
const value = property.property.value;
|
||||
processFunction(property.name, value, "methods");
|
||||
maybeFunctions.set(property.name, true);
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
this.maybeFunctions = maybeFunctions;
|
||||
this.functions = functions;
|
||||
/** @type {CallMember[]} */
|
||||
this.callMembers = [];
|
||||
/** @type {Map<Expression, boolean>} */
|
||||
this.cacheMaybeFunctionExpressions = /* @__PURE__ */ new Map();
|
||||
/**
|
||||
* @param {string} name
|
||||
* @param {Expression} value
|
||||
* @param {'methods' | 'computed'} kind
|
||||
*/
|
||||
function processFunction(name, value, kind) {
|
||||
if (value.type === "FunctionExpression") functions.push(new FunctionData(name, kind, value, context));
|
||||
else if (value.type === "ArrowFunctionExpression") {
|
||||
const data = new FunctionData(name, kind, value, context);
|
||||
if (value.expression) data.addReturnValue(value.body);
|
||||
functions.push(data);
|
||||
}
|
||||
}
|
||||
}
|
||||
/**
|
||||
* Adds the given return statement to the return value of the function.
|
||||
* @param {FunctionExpression | ArrowFunctionExpression | FunctionDeclaration} scopeFunction
|
||||
* @param {ReturnStatement} returnNode
|
||||
*/
|
||||
addReturnStatement(scopeFunction, returnNode) {
|
||||
for (const data of this.functions) if (data.node === scopeFunction) {
|
||||
data.addReturnValue(returnNode.argument);
|
||||
break;
|
||||
}
|
||||
}
|
||||
verifyComponent() {
|
||||
for (const call of this.callMembers) this.verifyCallMember(call);
|
||||
}
|
||||
/**
|
||||
* @param {CallMember} call
|
||||
*/
|
||||
verifyCallMember(call) {
|
||||
const fnData = this.functions.find((data) => data.name === call.name && data.kind === "computed");
|
||||
if (!fnData) return;
|
||||
if (!fnData.maybeReturnFunction(this)) {
|
||||
const prefix = call.node.callee.type === "MemberExpression" ? "this." : "";
|
||||
this.context.report({
|
||||
node: call.node,
|
||||
messageId: "unexpected",
|
||||
data: {
|
||||
likeProperty: `${prefix}${call.name}`,
|
||||
likeMethod: `${prefix}${call.name}()`
|
||||
}
|
||||
});
|
||||
}
|
||||
}
|
||||
/**
|
||||
* Check whether given expression may be a function.
|
||||
* @param {Expression} node
|
||||
* @returns {boolean}
|
||||
*/
|
||||
maybeFunctionExpression(node) {
|
||||
const cache = this.cacheMaybeFunctionExpressions.get(node);
|
||||
if (cache != null) return cache;
|
||||
this.cacheMaybeFunctionExpressions.set(node, true);
|
||||
const result = maybeFunctionExpressionWithoutCache.call(this);
|
||||
this.cacheMaybeFunctionExpressions.set(node, result);
|
||||
return result;
|
||||
/**
|
||||
* @this {ComponentStack}
|
||||
*/
|
||||
function maybeFunctionExpressionWithoutCache() {
|
||||
for (const expr of resolvedExpressions(this.context, node)) {
|
||||
if (!maybeFunction(this.context, expr)) continue;
|
||||
switch (expr.type) {
|
||||
case "MemberExpression":
|
||||
if (utils.isThis(expr.object, this.context)) {
|
||||
const name = utils.getStaticPropertyName(expr);
|
||||
if (name && !this.maybeFunctionProperty(name)) continue;
|
||||
}
|
||||
break;
|
||||
case "CallExpression":
|
||||
if (expr.callee.type === "MemberExpression" && utils.isThis(expr.callee.object, this.context)) {
|
||||
const name = utils.getStaticPropertyName(expr.callee);
|
||||
const fnData = this.functions.find((data) => data.name === name);
|
||||
if (fnData && fnData.kind === "methods" && !fnData.maybeReturnFunction(this)) continue;
|
||||
}
|
||||
break;
|
||||
case "ConditionalExpression":
|
||||
if (!this.maybeFunctionExpression(expr.consequent) && !this.maybeFunctionExpression(expr.alternate)) continue;
|
||||
break;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
}
|
||||
/**
|
||||
* Check whether given property name may be a function.
|
||||
* @param {string} name
|
||||
* @returns {boolean}
|
||||
*/
|
||||
maybeFunctionProperty(name) {
|
||||
const cache = this.maybeFunctions.get(name);
|
||||
if (cache != null) return cache;
|
||||
this.maybeFunctions.set(name, true);
|
||||
const result = maybeFunctionPropertyWithoutCache.call(this);
|
||||
this.maybeFunctions.set(name, result);
|
||||
return result;
|
||||
/**
|
||||
* @this {ComponentStack}
|
||||
*/
|
||||
function maybeFunctionPropertyWithoutCache() {
|
||||
const fnData = this.functions.find((data) => data.name === name);
|
||||
if (fnData && fnData.kind === "computed") return fnData.maybeReturnFunction(this);
|
||||
return true;
|
||||
}
|
||||
}
|
||||
};
|
||||
module.exports = {
|
||||
meta: {
|
||||
type: "problem",
|
||||
docs: {
|
||||
description: "disallow use computed property like method",
|
||||
categories: ["vue3-essential", "vue2-essential"],
|
||||
url: "https://eslint.vuejs.org/rules/no-use-computed-property-like-method.html"
|
||||
},
|
||||
fixable: null,
|
||||
schema: [],
|
||||
messages: { unexpected: "Use {{ likeProperty }} instead of {{ likeMethod }}." }
|
||||
},
|
||||
create(context) {
|
||||
/**
|
||||
* @typedef {object} ScopeStack
|
||||
* @property {ScopeStack | null} upper
|
||||
* @property {FunctionDeclaration | FunctionExpression | ArrowFunctionExpression} scopeNode
|
||||
*/
|
||||
/** @type {ScopeStack | null} */
|
||||
let scopeStack = null;
|
||||
/** @type {ComponentStack | null} */
|
||||
let componentStack = null;
|
||||
/** @type {ComponentStack | null} */
|
||||
let templateComponent = null;
|
||||
return utils.compositingVisitors({}, utils.defineVueVisitor(context, {
|
||||
onVueObjectEnter(node) {
|
||||
componentStack = new ComponentStack(node, context, componentStack);
|
||||
if (!templateComponent && utils.isInExportDefault(node)) templateComponent = componentStack;
|
||||
},
|
||||
onVueObjectExit() {
|
||||
if (componentStack) {
|
||||
componentStack.verifyComponent();
|
||||
componentStack = componentStack.upper;
|
||||
}
|
||||
},
|
||||
":function"(node) {
|
||||
scopeStack = {
|
||||
upper: scopeStack,
|
||||
scopeNode: node
|
||||
};
|
||||
},
|
||||
ReturnStatement(node) {
|
||||
if (scopeStack && componentStack) componentStack.addReturnStatement(scopeStack.scopeNode, node);
|
||||
},
|
||||
":function:exit"() {
|
||||
scopeStack = scopeStack && scopeStack.upper;
|
||||
},
|
||||
"ThisExpression, Identifier"(node) {
|
||||
if (!componentStack || node.parent.type !== "MemberExpression" || node.parent.object !== node || node.parent.parent.type !== "CallExpression" || node.parent.parent.callee !== node.parent || !utils.isThis(node, context)) return;
|
||||
const name = utils.getStaticPropertyName(node.parent);
|
||||
if (name) componentStack.callMembers.push({
|
||||
name,
|
||||
node: node.parent.parent
|
||||
});
|
||||
}
|
||||
}), utils.defineTemplateBodyVisitor(context, { VExpressionContainer(node) {
|
||||
if (!templateComponent) return;
|
||||
for (const id of node.references.filter((ref) => ref.variable == null).map((ref) => ref.id)) {
|
||||
if (id.parent.type !== "CallExpression" || id.parent.callee !== id) continue;
|
||||
templateComponent.verifyCallMember({
|
||||
name: id.name,
|
||||
node: id.parent
|
||||
});
|
||||
}
|
||||
} }));
|
||||
}
|
||||
};
|
||||
}));
|
||||
|
||||
//#endregion
|
||||
Object.defineProperty(exports, 'default', {
|
||||
enumerable: true,
|
||||
get: function () {
|
||||
return require_no_use_computed_property_like_method();
|
||||
}
|
||||
});
|
||||
Reference in New Issue
Block a user