386 lines
16 KiB
JavaScript
386 lines
16 KiB
JavaScript
|
"use strict";
|
||
|
|
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
|
||
|
|
if (k2 === undefined) k2 = k;
|
||
|
|
var desc = Object.getOwnPropertyDescriptor(m, k);
|
||
|
|
if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
|
||
|
|
desc = { enumerable: true, get: function() { return m[k]; } };
|
||
|
|
}
|
||
|
|
Object.defineProperty(o, k2, desc);
|
||
|
|
}) : (function(o, m, k, k2) {
|
||
|
|
if (k2 === undefined) k2 = k;
|
||
|
|
o[k2] = m[k];
|
||
|
|
}));
|
||
|
|
var __exportStar = (this && this.__exportStar) || function(m, exports) {
|
||
|
|
for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
|
||
|
|
};
|
||
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
||
|
|
exports.findImportSpecifier = exports.isEmptyFunction = exports.getStatementCallExpression = exports.hasImportMatch = exports.getInnermostReturningFunction = exports.hasClosestExpectResolvesRejects = exports.getAssertNodeInfo = exports.getImportModuleName = exports.getFunctionName = exports.getReferenceNode = exports.getDeepestIdentifierNode = exports.getPropertyIdentifierNode = exports.getFunctionReturnStatementNode = exports.getInnermostFunctionScope = exports.getVariableReferences = exports.isPromiseHandled = exports.isPromisesArrayResolved = exports.isPromiseAllSettled = exports.isPromiseAll = exports.isPromiseIdentifier = exports.hasChainedThen = exports.hasThenProperty = exports.findClosestCallNode = exports.findClosestVariableDeclaratorNode = exports.findClosestCallExpressionNode = void 0;
|
||
|
|
const utils_1 = require("@typescript-eslint/utils");
|
||
|
|
const is_node_of_type_1 = require("./is-node-of-type");
|
||
|
|
__exportStar(require("./is-node-of-type"), exports);
|
||
|
|
const ValidLeftHandSideExpressions = [
|
||
|
|
utils_1.AST_NODE_TYPES.CallExpression,
|
||
|
|
utils_1.AST_NODE_TYPES.ClassExpression,
|
||
|
|
utils_1.AST_NODE_TYPES.ClassDeclaration,
|
||
|
|
utils_1.AST_NODE_TYPES.FunctionExpression,
|
||
|
|
utils_1.AST_NODE_TYPES.Literal,
|
||
|
|
utils_1.AST_NODE_TYPES.TemplateLiteral,
|
||
|
|
utils_1.AST_NODE_TYPES.MemberExpression,
|
||
|
|
utils_1.AST_NODE_TYPES.ArrayExpression,
|
||
|
|
utils_1.AST_NODE_TYPES.ArrayPattern,
|
||
|
|
utils_1.AST_NODE_TYPES.ClassExpression,
|
||
|
|
utils_1.AST_NODE_TYPES.FunctionExpression,
|
||
|
|
utils_1.AST_NODE_TYPES.Identifier,
|
||
|
|
utils_1.AST_NODE_TYPES.JSXElement,
|
||
|
|
utils_1.AST_NODE_TYPES.JSXFragment,
|
||
|
|
utils_1.AST_NODE_TYPES.JSXOpeningElement,
|
||
|
|
utils_1.AST_NODE_TYPES.MetaProperty,
|
||
|
|
utils_1.AST_NODE_TYPES.ObjectExpression,
|
||
|
|
utils_1.AST_NODE_TYPES.ObjectPattern,
|
||
|
|
utils_1.AST_NODE_TYPES.Super,
|
||
|
|
utils_1.AST_NODE_TYPES.ThisExpression,
|
||
|
|
utils_1.AST_NODE_TYPES.TSNullKeyword,
|
||
|
|
utils_1.AST_NODE_TYPES.TaggedTemplateExpression,
|
||
|
|
utils_1.AST_NODE_TYPES.TSNonNullExpression,
|
||
|
|
utils_1.AST_NODE_TYPES.TSAsExpression,
|
||
|
|
utils_1.AST_NODE_TYPES.ArrowFunctionExpression,
|
||
|
|
];
|
||
|
|
function findClosestCallExpressionNode(node, shouldRestrictInnerScope = false) {
|
||
|
|
if ((0, is_node_of_type_1.isCallExpression)(node)) {
|
||
|
|
return node;
|
||
|
|
}
|
||
|
|
if (!(node === null || node === void 0 ? void 0 : node.parent)) {
|
||
|
|
return null;
|
||
|
|
}
|
||
|
|
if (shouldRestrictInnerScope &&
|
||
|
|
!ValidLeftHandSideExpressions.includes(node.parent.type)) {
|
||
|
|
return null;
|
||
|
|
}
|
||
|
|
return findClosestCallExpressionNode(node.parent, shouldRestrictInnerScope);
|
||
|
|
}
|
||
|
|
exports.findClosestCallExpressionNode = findClosestCallExpressionNode;
|
||
|
|
function findClosestVariableDeclaratorNode(node) {
|
||
|
|
if (!node) {
|
||
|
|
return null;
|
||
|
|
}
|
||
|
|
if (utils_1.ASTUtils.isVariableDeclarator(node)) {
|
||
|
|
return node;
|
||
|
|
}
|
||
|
|
return findClosestVariableDeclaratorNode(node.parent);
|
||
|
|
}
|
||
|
|
exports.findClosestVariableDeclaratorNode = findClosestVariableDeclaratorNode;
|
||
|
|
function findClosestCallNode(node, name) {
|
||
|
|
if (!node.parent) {
|
||
|
|
return null;
|
||
|
|
}
|
||
|
|
if ((0, is_node_of_type_1.isCallExpression)(node) &&
|
||
|
|
utils_1.ASTUtils.isIdentifier(node.callee) &&
|
||
|
|
node.callee.name === name) {
|
||
|
|
return node;
|
||
|
|
}
|
||
|
|
else {
|
||
|
|
return findClosestCallNode(node.parent, name);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
exports.findClosestCallNode = findClosestCallNode;
|
||
|
|
function hasThenProperty(node) {
|
||
|
|
return ((0, is_node_of_type_1.isMemberExpression)(node) &&
|
||
|
|
utils_1.ASTUtils.isIdentifier(node.property) &&
|
||
|
|
node.property.name === 'then');
|
||
|
|
}
|
||
|
|
exports.hasThenProperty = hasThenProperty;
|
||
|
|
function hasChainedThen(node) {
|
||
|
|
const parent = node.parent;
|
||
|
|
if ((0, is_node_of_type_1.isCallExpression)(parent) && parent.parent) {
|
||
|
|
return hasThenProperty(parent.parent);
|
||
|
|
}
|
||
|
|
return !!parent && hasThenProperty(parent);
|
||
|
|
}
|
||
|
|
exports.hasChainedThen = hasChainedThen;
|
||
|
|
function isPromiseIdentifier(node) {
|
||
|
|
return utils_1.ASTUtils.isIdentifier(node) && node.name === 'Promise';
|
||
|
|
}
|
||
|
|
exports.isPromiseIdentifier = isPromiseIdentifier;
|
||
|
|
function isPromiseAll(node) {
|
||
|
|
return ((0, is_node_of_type_1.isMemberExpression)(node.callee) &&
|
||
|
|
isPromiseIdentifier(node.callee.object) &&
|
||
|
|
utils_1.ASTUtils.isIdentifier(node.callee.property) &&
|
||
|
|
node.callee.property.name === 'all');
|
||
|
|
}
|
||
|
|
exports.isPromiseAll = isPromiseAll;
|
||
|
|
function isPromiseAllSettled(node) {
|
||
|
|
return ((0, is_node_of_type_1.isMemberExpression)(node.callee) &&
|
||
|
|
isPromiseIdentifier(node.callee.object) &&
|
||
|
|
utils_1.ASTUtils.isIdentifier(node.callee.property) &&
|
||
|
|
node.callee.property.name === 'allSettled');
|
||
|
|
}
|
||
|
|
exports.isPromiseAllSettled = isPromiseAllSettled;
|
||
|
|
function isPromisesArrayResolved(node) {
|
||
|
|
const closestCallExpression = findClosestCallExpressionNode(node, true);
|
||
|
|
if (!closestCallExpression) {
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
return (!!closestCallExpression.parent &&
|
||
|
|
(0, is_node_of_type_1.isArrayExpression)(closestCallExpression.parent) &&
|
||
|
|
(0, is_node_of_type_1.isCallExpression)(closestCallExpression.parent.parent) &&
|
||
|
|
(isPromiseAll(closestCallExpression.parent.parent) ||
|
||
|
|
isPromiseAllSettled(closestCallExpression.parent.parent)));
|
||
|
|
}
|
||
|
|
exports.isPromisesArrayResolved = isPromisesArrayResolved;
|
||
|
|
function isPromiseHandled(nodeIdentifier) {
|
||
|
|
const closestCallExpressionNode = findClosestCallExpressionNode(nodeIdentifier, true);
|
||
|
|
const suspiciousNodes = [nodeIdentifier, closestCallExpressionNode].filter(Boolean);
|
||
|
|
for (const node of suspiciousNodes) {
|
||
|
|
if (!(node === null || node === void 0 ? void 0 : node.parent)) {
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
if (utils_1.ASTUtils.isAwaitExpression(node.parent)) {
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
if ((0, is_node_of_type_1.isArrowFunctionExpression)(node.parent) ||
|
||
|
|
(0, is_node_of_type_1.isReturnStatement)(node.parent)) {
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
if (hasClosestExpectResolvesRejects(node.parent)) {
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
if (hasChainedThen(node)) {
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
if (isPromisesArrayResolved(node)) {
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
exports.isPromiseHandled = isPromiseHandled;
|
||
|
|
function getVariableReferences(context, node) {
|
||
|
|
var _a, _b, _c;
|
||
|
|
if (utils_1.ASTUtils.isVariableDeclarator(node)) {
|
||
|
|
return (_c = (_b = (_a = context.getDeclaredVariables(node)[0]) === null || _a === void 0 ? void 0 : _a.references) === null || _b === void 0 ? void 0 : _b.slice(1)) !== null && _c !== void 0 ? _c : [];
|
||
|
|
}
|
||
|
|
return [];
|
||
|
|
}
|
||
|
|
exports.getVariableReferences = getVariableReferences;
|
||
|
|
function getInnermostFunctionScope(context, asyncQueryNode) {
|
||
|
|
const innermostScope = utils_1.ASTUtils.getInnermostScope(context.getScope(), asyncQueryNode);
|
||
|
|
if (innermostScope.type === 'function' &&
|
||
|
|
utils_1.ASTUtils.isFunction(innermostScope.block)) {
|
||
|
|
return innermostScope;
|
||
|
|
}
|
||
|
|
return null;
|
||
|
|
}
|
||
|
|
exports.getInnermostFunctionScope = getInnermostFunctionScope;
|
||
|
|
function getFunctionReturnStatementNode(functionNode) {
|
||
|
|
if ((0, is_node_of_type_1.isBlockStatement)(functionNode.body)) {
|
||
|
|
const returnStatementNode = functionNode.body.body.find((statement) => (0, is_node_of_type_1.isReturnStatement)(statement));
|
||
|
|
if (!returnStatementNode) {
|
||
|
|
return null;
|
||
|
|
}
|
||
|
|
return returnStatementNode.argument;
|
||
|
|
}
|
||
|
|
else if (functionNode.expression) {
|
||
|
|
return functionNode.body;
|
||
|
|
}
|
||
|
|
return null;
|
||
|
|
}
|
||
|
|
exports.getFunctionReturnStatementNode = getFunctionReturnStatementNode;
|
||
|
|
function getPropertyIdentifierNode(node) {
|
||
|
|
if (utils_1.ASTUtils.isIdentifier(node)) {
|
||
|
|
return node;
|
||
|
|
}
|
||
|
|
if ((0, is_node_of_type_1.isMemberExpression)(node)) {
|
||
|
|
return getPropertyIdentifierNode(node.object);
|
||
|
|
}
|
||
|
|
if ((0, is_node_of_type_1.isCallExpression)(node)) {
|
||
|
|
return getPropertyIdentifierNode(node.callee);
|
||
|
|
}
|
||
|
|
if ((0, is_node_of_type_1.isExpressionStatement)(node)) {
|
||
|
|
return getPropertyIdentifierNode(node.expression);
|
||
|
|
}
|
||
|
|
return null;
|
||
|
|
}
|
||
|
|
exports.getPropertyIdentifierNode = getPropertyIdentifierNode;
|
||
|
|
function getDeepestIdentifierNode(node) {
|
||
|
|
if (utils_1.ASTUtils.isIdentifier(node)) {
|
||
|
|
return node;
|
||
|
|
}
|
||
|
|
if ((0, is_node_of_type_1.isMemberExpression)(node) && utils_1.ASTUtils.isIdentifier(node.property)) {
|
||
|
|
return node.property;
|
||
|
|
}
|
||
|
|
if ((0, is_node_of_type_1.isCallExpression)(node)) {
|
||
|
|
return getDeepestIdentifierNode(node.callee);
|
||
|
|
}
|
||
|
|
if (utils_1.ASTUtils.isAwaitExpression(node)) {
|
||
|
|
return getDeepestIdentifierNode(node.argument);
|
||
|
|
}
|
||
|
|
return null;
|
||
|
|
}
|
||
|
|
exports.getDeepestIdentifierNode = getDeepestIdentifierNode;
|
||
|
|
function getReferenceNode(node) {
|
||
|
|
if (node.parent &&
|
||
|
|
((0, is_node_of_type_1.isMemberExpression)(node.parent) || (0, is_node_of_type_1.isCallExpression)(node.parent))) {
|
||
|
|
return getReferenceNode(node.parent);
|
||
|
|
}
|
||
|
|
return node;
|
||
|
|
}
|
||
|
|
exports.getReferenceNode = getReferenceNode;
|
||
|
|
function getFunctionName(node) {
|
||
|
|
var _a, _b;
|
||
|
|
return ((_b = (_a = utils_1.ASTUtils.getFunctionNameWithKind(node)
|
||
|
|
.match(/('\w+')/g)) === null || _a === void 0 ? void 0 : _a[0].replace(/'/g, '')) !== null && _b !== void 0 ? _b : '');
|
||
|
|
}
|
||
|
|
exports.getFunctionName = getFunctionName;
|
||
|
|
function getImportModuleName(node) {
|
||
|
|
if ((0, is_node_of_type_1.isImportDeclaration)(node) && typeof node.source.value === 'string') {
|
||
|
|
return node.source.value;
|
||
|
|
}
|
||
|
|
if ((0, is_node_of_type_1.isCallExpression)(node) &&
|
||
|
|
(0, is_node_of_type_1.isLiteral)(node.arguments[0]) &&
|
||
|
|
typeof node.arguments[0].value === 'string') {
|
||
|
|
return node.arguments[0].value;
|
||
|
|
}
|
||
|
|
return undefined;
|
||
|
|
}
|
||
|
|
exports.getImportModuleName = getImportModuleName;
|
||
|
|
function getAssertNodeInfo(node) {
|
||
|
|
const emptyInfo = { matcher: null, isNegated: false };
|
||
|
|
if (!(0, is_node_of_type_1.isCallExpression)(node.object) ||
|
||
|
|
!utils_1.ASTUtils.isIdentifier(node.object.callee)) {
|
||
|
|
return emptyInfo;
|
||
|
|
}
|
||
|
|
if (node.object.callee.name !== 'expect') {
|
||
|
|
return emptyInfo;
|
||
|
|
}
|
||
|
|
let matcher = utils_1.ASTUtils.getPropertyName(node);
|
||
|
|
const isNegated = matcher === 'not';
|
||
|
|
if (isNegated) {
|
||
|
|
matcher =
|
||
|
|
node.parent && (0, is_node_of_type_1.isMemberExpression)(node.parent)
|
||
|
|
? utils_1.ASTUtils.getPropertyName(node.parent)
|
||
|
|
: null;
|
||
|
|
}
|
||
|
|
if (!matcher) {
|
||
|
|
return emptyInfo;
|
||
|
|
}
|
||
|
|
return { matcher, isNegated };
|
||
|
|
}
|
||
|
|
exports.getAssertNodeInfo = getAssertNodeInfo;
|
||
|
|
const matcherNamesHandlePromise = [
|
||
|
|
'resolves',
|
||
|
|
'rejects',
|
||
|
|
'toResolve',
|
||
|
|
'toReject',
|
||
|
|
];
|
||
|
|
function hasClosestExpectResolvesRejects(node) {
|
||
|
|
if ((0, is_node_of_type_1.isCallExpression)(node) &&
|
||
|
|
utils_1.ASTUtils.isIdentifier(node.callee) &&
|
||
|
|
node.parent &&
|
||
|
|
(0, is_node_of_type_1.isMemberExpression)(node.parent) &&
|
||
|
|
node.callee.name === 'expect') {
|
||
|
|
const expectMatcher = node.parent.property;
|
||
|
|
return (utils_1.ASTUtils.isIdentifier(expectMatcher) &&
|
||
|
|
matcherNamesHandlePromise.includes(expectMatcher.name));
|
||
|
|
}
|
||
|
|
if (!node.parent) {
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
return hasClosestExpectResolvesRejects(node.parent);
|
||
|
|
}
|
||
|
|
exports.hasClosestExpectResolvesRejects = hasClosestExpectResolvesRejects;
|
||
|
|
function getInnermostReturningFunction(context, node) {
|
||
|
|
const functionScope = getInnermostFunctionScope(context, node);
|
||
|
|
if (!functionScope) {
|
||
|
|
return undefined;
|
||
|
|
}
|
||
|
|
const returnStatementNode = getFunctionReturnStatementNode(functionScope.block);
|
||
|
|
if (!returnStatementNode) {
|
||
|
|
return undefined;
|
||
|
|
}
|
||
|
|
const returnStatementIdentifier = getDeepestIdentifierNode(returnStatementNode);
|
||
|
|
if ((returnStatementIdentifier === null || returnStatementIdentifier === void 0 ? void 0 : returnStatementIdentifier.name) !== node.name) {
|
||
|
|
return undefined;
|
||
|
|
}
|
||
|
|
return functionScope.block;
|
||
|
|
}
|
||
|
|
exports.getInnermostReturningFunction = getInnermostReturningFunction;
|
||
|
|
function hasImportMatch(importNode, identifierName) {
|
||
|
|
if (utils_1.ASTUtils.isIdentifier(importNode)) {
|
||
|
|
return importNode.name === identifierName;
|
||
|
|
}
|
||
|
|
return importNode.local.name === identifierName;
|
||
|
|
}
|
||
|
|
exports.hasImportMatch = hasImportMatch;
|
||
|
|
function getStatementCallExpression(statement) {
|
||
|
|
if ((0, is_node_of_type_1.isExpressionStatement)(statement)) {
|
||
|
|
const { expression } = statement;
|
||
|
|
if ((0, is_node_of_type_1.isCallExpression)(expression)) {
|
||
|
|
return expression;
|
||
|
|
}
|
||
|
|
if (utils_1.ASTUtils.isAwaitExpression(expression) &&
|
||
|
|
(0, is_node_of_type_1.isCallExpression)(expression.argument)) {
|
||
|
|
return expression.argument;
|
||
|
|
}
|
||
|
|
if ((0, is_node_of_type_1.isAssignmentExpression)(expression)) {
|
||
|
|
if ((0, is_node_of_type_1.isCallExpression)(expression.right)) {
|
||
|
|
return expression.right;
|
||
|
|
}
|
||
|
|
if (utils_1.ASTUtils.isAwaitExpression(expression.right) &&
|
||
|
|
(0, is_node_of_type_1.isCallExpression)(expression.right.argument)) {
|
||
|
|
return expression.right.argument;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if ((0, is_node_of_type_1.isReturnStatement)(statement) && (0, is_node_of_type_1.isCallExpression)(statement.argument)) {
|
||
|
|
return statement.argument;
|
||
|
|
}
|
||
|
|
if ((0, is_node_of_type_1.isVariableDeclaration)(statement)) {
|
||
|
|
for (const declaration of statement.declarations) {
|
||
|
|
if ((0, is_node_of_type_1.isCallExpression)(declaration.init)) {
|
||
|
|
return declaration.init;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return undefined;
|
||
|
|
}
|
||
|
|
exports.getStatementCallExpression = getStatementCallExpression;
|
||
|
|
function isEmptyFunction(node) {
|
||
|
|
if (utils_1.ASTUtils.isFunction(node) && (0, is_node_of_type_1.isBlockStatement)(node.body)) {
|
||
|
|
return node.body.body.length === 0;
|
||
|
|
}
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
exports.isEmptyFunction = isEmptyFunction;
|
||
|
|
function findImportSpecifier(specifierName, node) {
|
||
|
|
if ((0, is_node_of_type_1.isImportDeclaration)(node)) {
|
||
|
|
const namedExport = node.specifiers.find((n) => {
|
||
|
|
return ((0, is_node_of_type_1.isImportSpecifier)(n) &&
|
||
|
|
[n.imported.name, n.local.name].includes(specifierName));
|
||
|
|
});
|
||
|
|
if (namedExport) {
|
||
|
|
return namedExport;
|
||
|
|
}
|
||
|
|
return node.specifiers.find((n) => (0, is_node_of_type_1.isImportNamespaceSpecifier)(n));
|
||
|
|
}
|
||
|
|
else {
|
||
|
|
if (!utils_1.ASTUtils.isVariableDeclarator(node.parent)) {
|
||
|
|
return undefined;
|
||
|
|
}
|
||
|
|
const requireNode = node.parent;
|
||
|
|
if (utils_1.ASTUtils.isIdentifier(requireNode.id)) {
|
||
|
|
return requireNode.id;
|
||
|
|
}
|
||
|
|
if (!(0, is_node_of_type_1.isObjectPattern)(requireNode.id)) {
|
||
|
|
return undefined;
|
||
|
|
}
|
||
|
|
const property = requireNode.id.properties.find((n) => (0, is_node_of_type_1.isProperty)(n) &&
|
||
|
|
utils_1.ASTUtils.isIdentifier(n.key) &&
|
||
|
|
n.key.name === specifierName);
|
||
|
|
if (!property) {
|
||
|
|
return undefined;
|
||
|
|
}
|
||
|
|
return property.key;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
exports.findImportSpecifier = findImportSpecifier;
|