eslint-plugin-vue
Version:
Official ESLint plugin for Vue.js
282 lines (281 loc) • 9.36 kB
JavaScript
"use strict";
const require_runtime = require("../_virtual/_rolldown/runtime.js");
const require_index = require("../utils/index.js");
//#region lib/rules/no-async-in-computed-properties.js
/**
* @fileoverview Check if there are no asynchronous actions inside computed properties.
* @author Armano
*/
var require_no_async_in_computed_properties = /* @__PURE__ */ require_runtime.__commonJSMin(((exports, module) => {
const { ReferenceTracker } = require("@eslint-community/eslint-utils");
const utils = require_index.default;
/**
* @typedef {import('../utils').VueObjectData} VueObjectData
* @typedef {import('../utils').VueVisitor} VueVisitor
* @typedef {import('../utils').ComponentComputedProperty} ComponentComputedProperty
*/
const PROMISE_FUNCTIONS = /* @__PURE__ */ new Set([
"then",
"catch",
"finally"
]);
const PROMISE_METHODS = /* @__PURE__ */ new Set([
"all",
"allSettled",
"any",
"race",
"reject",
"resolve",
"try",
"withResolvers"
]);
const TIMED_FUNCTIONS = /* @__PURE__ */ new Set([
"setTimeout",
"setInterval",
"setImmediate",
"requestAnimationFrame"
]);
/**
* @param {CallExpression} node
*/
function isTimedFunction(node) {
const callee = utils.skipChainExpression(node.callee);
return (callee.type === "Identifier" && TIMED_FUNCTIONS.has(callee.name) || callee.type === "MemberExpression" && callee.object.type === "Identifier" && callee.object.name === "window" && TIMED_FUNCTIONS.has(utils.getStaticPropertyName(callee) || "")) && node.arguments.length > 0;
}
/**
* @param {*} node
* @returns {*}
*/
function skipWrapper(node) {
while (node && node.expression) node = node.expression;
return node;
}
/**
* Resolve a single step of the member expression chain walk.
* @param {*} current
* @returns {{ done: true, name: string | null } | { done: false, next: * }}
*/
function resolveRootObjectStep(current) {
switch (current.type) {
case "MemberExpression": return {
done: false,
next: skipWrapper(current.object)
};
case "CallExpression": {
const calleeExpr = skipWrapper(current.callee);
if (calleeExpr.type === "MemberExpression") return {
done: false,
next: skipWrapper(calleeExpr.object)
};
if (calleeExpr.type === "Identifier") return {
done: true,
name: calleeExpr.name
};
return {
done: true,
name: null
};
}
case "Identifier": return {
done: true,
name: current.name
};
default: return {
done: true,
name: null
};
}
}
/**
* Get the root object name from a member expression chain
* @param {MemberExpression} memberExpr
* @returns {string|null}
*/
function getRootObjectName(memberExpr) {
let current = skipWrapper(memberExpr.object);
while (current) {
const step = resolveRootObjectStep(current);
if (step.done) return step.name;
current = step.next;
}
return null;
}
/**
* @param {string} name
* @param {*} callee
* @returns {boolean}
*/
function isPromiseMethod(name, callee) {
return PROMISE_FUNCTIONS.has(name) || callee.object.type === "Identifier" && callee.object.name === "Promise" && PROMISE_METHODS.has(name);
}
/**
* @param {CallExpression} node
* @param {Set<string>} ignoredObjectNames
*/
function isPromise(node, ignoredObjectNames) {
const callee = utils.skipChainExpression(node.callee);
if (callee.type === "MemberExpression") {
const name = utils.getStaticPropertyName(callee);
if (!name || !isPromiseMethod(name, callee)) return false;
const rootObjectName = getRootObjectName(callee);
return !rootObjectName || !ignoredObjectNames.has(rootObjectName);
}
return false;
}
/**
* @param {CallExpression} node
* @param {RuleContext} context
*/
function isNextTick(node, context) {
const callee = utils.skipChainExpression(node.callee);
if (callee.type === "MemberExpression") {
const name = utils.getStaticPropertyName(callee);
return utils.isThis(callee.object, context) && name === "$nextTick" || callee.object.type === "Identifier" && callee.object.name === "Vue" && name === "nextTick";
}
return false;
}
module.exports = {
meta: {
type: "problem",
docs: {
description: "disallow asynchronous actions in computed properties",
categories: ["vue3-essential", "vue2-essential"],
url: "https://eslint.vuejs.org/rules/no-async-in-computed-properties.html"
},
fixable: null,
schema: [{
type: "object",
properties: { ignoredObjectNames: {
type: "array",
items: { type: "string" },
uniqueItems: true,
additionalItems: false
} },
additionalProperties: false
}],
messages: {
unexpectedInFunction: "Unexpected {{expressionName}} in computed function.",
unexpectedInProperty: "Unexpected {{expressionName}} in \"{{propertyName}}\" computed property."
}
},
/** @param {RuleContext} context */
create(context) {
const options = context.options[0] || {};
const ignoredObjectNames = new Set(options.ignoredObjectNames || []);
/** @type {Map<ObjectExpression, ComponentComputedProperty[]>} */
const computedPropertiesMap = /* @__PURE__ */ new Map();
/** @type {(FunctionExpression | ArrowFunctionExpression)[]} */
const computedFunctionNodes = [];
/**
* @typedef {object} ScopeStack
* @property {ScopeStack | null} upper
* @property {BlockStatement | Expression} body
*/
/** @type {ScopeStack | null} */
let scopeStack = null;
const expressionTypes = {
promise: "asynchronous action",
nextTick: "asynchronous action",
await: "await operator",
async: "async function declaration",
new: "Promise object",
timed: "timed function"
};
/**
* @param {FunctionExpression | FunctionDeclaration | ArrowFunctionExpression} node
* @param {VueObjectData|undefined} [info]
*/
function onFunctionEnter(node, info) {
if (node.async) verify(node, node.body, "async", info ? computedPropertiesMap.get(info.node) : null);
scopeStack = {
upper: scopeStack,
body: node.body
};
}
function onFunctionExit() {
scopeStack &&= scopeStack.upper;
}
/**
* @param {ESNode} node
* @param {BlockStatement | Expression} targetBody
* @param {keyof expressionTypes} type
* @param {ComponentComputedProperty[]|undefined|null} computedProperties
*/
function verify(node, targetBody, type, computedProperties) {
const properties = computedProperties || [];
for (const cp of properties) if (cp.value && node.loc.start.line >= cp.value.loc.start.line && node.loc.end.line <= cp.value.loc.end.line && targetBody === cp.value) {
context.report({
node,
messageId: "unexpectedInProperty",
data: {
expressionName: expressionTypes[type],
propertyName: cp.key || "unknown"
}
});
return;
}
for (const cf of computedFunctionNodes) if (node.loc.start.line >= cf.body.loc.start.line && node.loc.end.line <= cf.body.loc.end.line && targetBody === cf.body) {
context.report({
node,
messageId: "unexpectedInFunction",
data: { expressionName: expressionTypes[type] }
});
return;
}
}
const nodeVisitor = {
":function": onFunctionEnter,
":function:exit": onFunctionExit,
/**
* @param {NewExpression} node
* @param {VueObjectData|undefined} [info]
*/
NewExpression(node, info) {
if (!scopeStack) return;
if (node.callee.type === "Identifier" && node.callee.name === "Promise") verify(node, scopeStack.body, "new", info ? computedPropertiesMap.get(info.node) : null);
},
/**
* @param {CallExpression} node
* @param {VueObjectData|undefined} [info]
*/
CallExpression(node, info) {
if (!scopeStack) return;
if (isPromise(node, ignoredObjectNames)) verify(node, scopeStack.body, "promise", info ? computedPropertiesMap.get(info.node) : null);
else if (isTimedFunction(node)) verify(node, scopeStack.body, "timed", info ? computedPropertiesMap.get(info.node) : null);
else if (isNextTick(node, context)) verify(node, scopeStack.body, "nextTick", info ? computedPropertiesMap.get(info.node) : null);
},
/**
* @param {AwaitExpression} node
* @param {VueObjectData|undefined} [info]
*/
AwaitExpression(node, info) {
if (!scopeStack) return;
verify(node, scopeStack.body, "await", info ? computedPropertiesMap.get(info.node) : null);
}
};
return utils.compositingVisitors({
/** @param {Program} program */
Program(program) {
const tracker = new ReferenceTracker(utils.getScope(context, program));
const computedRefs = utils.iterateReferencesTraceMap(tracker, { computed: { [ReferenceTracker.CALL]: true } });
for (const { node } of computedRefs) {
if (node.type !== "CallExpression") continue;
const getter = utils.getGetterBodyFromComputedFunction(node);
if (getter) computedFunctionNodes.push(getter);
}
} }, utils.isScriptSetup(context) ? utils.defineScriptSetupVisitor(context, nodeVisitor) : utils.defineVueVisitor(context, {
onVueObjectEnter(node) {
computedPropertiesMap.set(node, utils.getComputedProperties(node));
},
...nodeVisitor
}));
}
};
}));
//#endregion
Object.defineProperty(exports, "default", {
enumerable: true,
get: function() {
return require_no_async_in_computed_properties();
}
});