Index: frontend/node_modules/eslint-plugin-testing-library/node-utils/index.js =================================================================== --- frontend/node_modules/eslint-plugin-testing-library/node-utils/index.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/eslint-plugin-testing-library/node-utils/index.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,385 @@ +"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; Index: frontend/node_modules/eslint-plugin-testing-library/node-utils/is-node-of-type.js =================================================================== --- frontend/node_modules/eslint-plugin-testing-library/node-utils/is-node-of-type.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) +++ frontend/node_modules/eslint-plugin-testing-library/node-utils/is-node-of-type.js (revision 9af201e94b5a79beb92a30858fc54de4bc3b9449) @@ -0,0 +1,25 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.isFunctionExpression = exports.isReturnStatement = exports.isProperty = exports.isObjectPattern = exports.isObjectExpression = exports.isNewExpression = exports.isMemberExpression = exports.isLiteral = exports.isJSXAttribute = exports.isImportSpecifier = exports.isImportNamespaceSpecifier = exports.isImportDefaultSpecifier = exports.isImportDeclaration = exports.isSequenceExpression = exports.isAssignmentExpression = exports.isVariableDeclaration = exports.isExpressionStatement = exports.isCallExpression = exports.isBlockStatement = exports.isArrowFunctionExpression = exports.isArrayExpression = void 0; +const utils_1 = require("@typescript-eslint/utils"); +exports.isArrayExpression = utils_1.ASTUtils.isNodeOfType(utils_1.AST_NODE_TYPES.ArrayExpression); +exports.isArrowFunctionExpression = utils_1.ASTUtils.isNodeOfType(utils_1.AST_NODE_TYPES.ArrowFunctionExpression); +exports.isBlockStatement = utils_1.ASTUtils.isNodeOfType(utils_1.AST_NODE_TYPES.BlockStatement); +exports.isCallExpression = utils_1.ASTUtils.isNodeOfType(utils_1.AST_NODE_TYPES.CallExpression); +exports.isExpressionStatement = utils_1.ASTUtils.isNodeOfType(utils_1.AST_NODE_TYPES.ExpressionStatement); +exports.isVariableDeclaration = utils_1.ASTUtils.isNodeOfType(utils_1.AST_NODE_TYPES.VariableDeclaration); +exports.isAssignmentExpression = utils_1.ASTUtils.isNodeOfType(utils_1.AST_NODE_TYPES.AssignmentExpression); +exports.isSequenceExpression = utils_1.ASTUtils.isNodeOfType(utils_1.AST_NODE_TYPES.SequenceExpression); +exports.isImportDeclaration = utils_1.ASTUtils.isNodeOfType(utils_1.AST_NODE_TYPES.ImportDeclaration); +exports.isImportDefaultSpecifier = utils_1.ASTUtils.isNodeOfType(utils_1.AST_NODE_TYPES.ImportDefaultSpecifier); +exports.isImportNamespaceSpecifier = utils_1.ASTUtils.isNodeOfType(utils_1.AST_NODE_TYPES.ImportNamespaceSpecifier); +exports.isImportSpecifier = utils_1.ASTUtils.isNodeOfType(utils_1.AST_NODE_TYPES.ImportSpecifier); +exports.isJSXAttribute = utils_1.ASTUtils.isNodeOfType(utils_1.AST_NODE_TYPES.JSXAttribute); +exports.isLiteral = utils_1.ASTUtils.isNodeOfType(utils_1.AST_NODE_TYPES.Literal); +exports.isMemberExpression = utils_1.ASTUtils.isNodeOfType(utils_1.AST_NODE_TYPES.MemberExpression); +exports.isNewExpression = utils_1.ASTUtils.isNodeOfType(utils_1.AST_NODE_TYPES.NewExpression); +exports.isObjectExpression = utils_1.ASTUtils.isNodeOfType(utils_1.AST_NODE_TYPES.ObjectExpression); +exports.isObjectPattern = utils_1.ASTUtils.isNodeOfType(utils_1.AST_NODE_TYPES.ObjectPattern); +exports.isProperty = utils_1.ASTUtils.isNodeOfType(utils_1.AST_NODE_TYPES.Property); +exports.isReturnStatement = utils_1.ASTUtils.isNodeOfType(utils_1.AST_NODE_TYPES.ReturnStatement); +exports.isFunctionExpression = utils_1.ASTUtils.isNodeOfType(utils_1.AST_NODE_TYPES.FunctionExpression);