241 lines
8.2 KiB
JavaScript
241 lines
8.2 KiB
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 = new Set([
|
|
"then",
|
|
"catch",
|
|
"finally"
|
|
]);
|
|
const PROMISE_METHODS = new Set([
|
|
"all",
|
|
"allSettled",
|
|
"any",
|
|
"race",
|
|
"reject",
|
|
"resolve",
|
|
"try",
|
|
"withResolvers"
|
|
]);
|
|
const TIMED_FUNCTIONS = 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;
|
|
}
|
|
/**
|
|
* 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) switch (current.type) {
|
|
case "MemberExpression":
|
|
current = skipWrapper(current.object);
|
|
break;
|
|
case "CallExpression": {
|
|
const calleeExpr = skipWrapper(current.callee);
|
|
if (calleeExpr.type === "MemberExpression") current = skipWrapper(calleeExpr.object);
|
|
else if (calleeExpr.type === "Identifier") return calleeExpr.name;
|
|
else return null;
|
|
break;
|
|
}
|
|
case "Identifier": return current.name;
|
|
default: return null;
|
|
}
|
|
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);
|
|
if (rootObjectName && ignoredObjectNames.has(rootObjectName)) return false;
|
|
return true;
|
|
}
|
|
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."
|
|
}
|
|
},
|
|
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 && scopeStack.upper;
|
|
}
|
|
/**
|
|
* @param {ESNode} node
|
|
* @param {BlockStatement | Expression} targetBody
|
|
* @param {keyof expressionTypes} type
|
|
* @param {ComponentComputedProperty[]|undefined|null} computedProperties
|
|
*/
|
|
function verify(node, targetBody, type, computedProperties) {
|
|
for (const cp of computedProperties || []) 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,
|
|
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);
|
|
},
|
|
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);
|
|
},
|
|
AwaitExpression(node, info) {
|
|
if (!scopeStack) return;
|
|
verify(node, scopeStack.body, "await", info ? computedPropertiesMap.get(info.node) : null);
|
|
}
|
|
};
|
|
return utils.compositingVisitors({ Program(program) {
|
|
const tracker = new ReferenceTracker(utils.getScope(context, program));
|
|
for (const { node } of utils.iterateReferencesTraceMap(tracker, { computed: { [ReferenceTracker.CALL]: true } })) {
|
|
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();
|
|
}
|
|
}); |