eslint-plugin-sonarjs 4.0.3 → 4.1.0

package/cjs/helpers/playwright.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isDescribe = isDescribe;
+const ast_js_1 = require("./ast.js");
+const describeModifiers = ['parallel', 'serial'];
+function isDescribe(node) {
+    if (node?.type !== 'MemberExpression' || node.computed) {
+        return false;
+    }
+    const { object, property } = node;
+    return (((0, ast_js_1.isIdentifier)(object, 'test') && (0, ast_js_1.isIdentifier)(property, 'describe')) ||
+        ((0, ast_js_1.isIdentifier)(property, ...describeModifiers) && isDescribe(object)));
+}

package/cjs/helpers/regex/extract.js

@@ -58,34 +58,46 @@ function getPatternFromNode(node, context) {
         if (patternOnly && flags !== null) {
             // if we can't extract flags correctly, we skip this
             // to avoid FPs
-            return { pattern: patternOnly.pattern, flags };
+            return { ...patternOnly, flags };
         }
     }
     else if ((0, ast_js_1.isRegexLiteral)(node)) {
-        return node.regex;
+        return literalPattern(node.regex.pattern, node.regex.flags);
     }
     else if ((0, ast_js_1.isStringLiteral)(node)) {
-        return { pattern: node.value, flags: '' };
+        return literalPattern(node.value);
     }
     else if ((0, ast_js_1.isStaticTemplateLiteral)(node)) {
-        return { pattern: node.quasis[0].value.raw, flags: '' };
+        return literalPattern(node.quasis[0].value.raw);
     }
     else if ((0, ast_js_1.isSimpleRawString)(node)) {
-        return { pattern: (0, ast_js_1.getSimpleRawStringValue)(node), flags: '' };
+        return literalPattern((0, ast_js_1.getSimpleRawStringValue)(node));
     }
     else if ((0, ast_js_1.isIdentifier)(node)) {
         const assignedExpression = (0, ast_js_1.getUniqueWriteUsage)(context, node.name, node);
         if (assignedExpression &&
             assignedExpression.parent?.type === 'VariableDeclarator') {
-            return getPatternFromNode(assignedExpression, context);
+            const pattern = getPatternFromNode(assignedExpression, context);
+            return pattern ? { ...pattern, isPureLiteral: false } : null;
         }
     }
     else if ((0, ast_js_1.isBinaryPlus)(node)) {
         const left = getPatternFromNode(node.left, context);
         const right = getPatternFromNode(node.right, context);
-        if (left && right) {
-            return { pattern: left.pattern + right.pattern, flags: '' };
-        }
+        return left && right ? concatPatterns(left, right) : null;
     }
     return null;
 }
+function literalPattern(pattern, flags = '') {
+    return { pattern, flags, seams: [], isPureLiteral: true };
+}
+function concatPatterns(left, right) {
+    const splitOffset = left.pattern.length;
+    const splitSeams = left.isPureLiteral && right.isPureLiteral ? [] : [splitOffset];
+    return {
+        pattern: left.pattern + right.pattern,
+        flags: '',
+        seams: [...left.seams, ...splitSeams, ...right.seams.map(s => s + splitOffset)],
+        isPureLiteral: left.isPureLiteral && right.isPureLiteral,
+    };
+}

package/cjs/helpers/regex/flags.js

@@ -8,18 +8,25 @@ function getFlags(callExpr, context) {
         return '';
     }
     const flags = callExpr.arguments[1];
-    // Matches flags in: new RegExp(pattern, 'u')
-    if ((0, ast_js_1.isStringLiteral)(flags)) {
-        return flags.value;
+    const staticFlags = getStaticFlagsValue(flags);
+    if (staticFlags !== null) {
+        return staticFlags;
     }
     if (flags.type === 'Identifier' && context !== undefined) {
         // it's a variable, so we try to extract its value, but only if it's written once (const)
         const variable = (0, reaching_definitions_js_1.getVariableFromIdentifier)(flags, context.sourceCode.getScope(callExpr));
         const ref = (0, ast_js_1.getUniqueWriteReference)(variable);
-        if (ref !== undefined && (0, ast_js_1.isStringLiteral)(ref)) {
-            return ref.value;
+        if (ref !== undefined) {
+            return getStaticFlagsValue(ref);
         }
     }
+    return null;
+}
+function getStaticFlagsValue(flags) {
+    // Matches flags in: new RegExp(pattern, 'u')
+    if ((0, ast_js_1.isStringLiteral)(flags)) {
+        return flags.value;
+    }
     // Matches flags with basic template literals as in: new RegExp(pattern, `u`)
     // but not: new RegExp(pattern, `${flag}`)
     // The cooked value should always be non-null in this case.

package/cjs/helpers/sinon.js

@@ -3,15 +3,11 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isImported = isImported;
 exports.isAssertion = isAssertion;
 exports.isTSAssertion = isTSAssertion;
 const module_js_1 = require("./module.js");
 const module_ts_js_1 = require("./module-ts.js");
 const typescript_1 = __importDefault(require("typescript"));
-function isImported(context) {
-    return ((0, module_js_1.getRequireCalls)(context).some(r => r.arguments[0].type === 'Literal' && r.arguments[0].value === 'sinon') || (0, module_js_1.getImportDeclarations)(context).some(i => i.source.value === 'sinon'));
-}
 function isAssertion(context, node) {
     return isAssertUsage(context, node);
 }

package/cjs/helpers/supertest.js

@@ -3,15 +3,11 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isImported = isImported;
 exports.isAssertion = isAssertion;
 exports.isTSAssertion = isTSAssertion;
 const module_js_1 = require("./module.js");
 const module_ts_js_1 = require("./module-ts.js");
 const typescript_1 = __importDefault(require("typescript"));
-function isImported(context) {
-    return ((0, module_js_1.getRequireCalls)(context).some(r => r.arguments[0].type === 'Literal' && r.arguments[0].value === 'supertest') || (0, module_js_1.getImportDeclarations)(context).some(i => i.source.value === 'supertest'));
-}
 function isAssertion(context, node) {
     const fqn = extractFQNForCallExpression(context, node);
     return isFQNAssertion(fqn);

package/cjs/helpers/test-file-pattern.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_TEST_FILE_EXTENSIONS = void 0;
+exports.isTestFile = isTestFile;
+exports.isTestRelatedFile = isTestRelatedFile;
+/*
+ * SonarQube JavaScript Plugin
+ * Copyright (C) SonarSource Sàrl
+ * mailto:info AT sonarsource DOT com
+ *
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the Sonar Source-Available License for more details.
+ *
+ * You should have received a copy of the Sonar Source-Available License
+ * along with this program; if not, see https://sonarsource.com/license/ssal/
+ */
+exports.DEFAULT_TEST_FILE_EXTENSIONS = [
+    '.js',
+    '.mjs',
+    '.cjs',
+    '.jsx',
+    '.vue',
+    '.ts',
+    '.mts',
+    '.cts',
+    '.tsx',
+];
+function suffixAlternation(extensions) {
+    const effective = extensions?.length ? extensions : exports.DEFAULT_TEST_FILE_EXTENSIONS;
+    return effective.map(ext => (ext.startsWith('.') ? ext.slice(1) : ext)).join('|');
+}
+function testFilePattern(extensions) {
+    return new RegExp(String.raw `\.(?:test|spec|cy)\.(?:${suffixAlternation(extensions)})$`);
+}
+function testRelatedFilePattern(extensions) {
+    const alternation = suffixAlternation(extensions);
+    return new RegExp(String.raw `\.(?:test|spec|cy)\.(?:${alternation})$|\.(?:e2e|mock)\.(?:${alternation})$|(?:^|[\\/])(?:__tests__|__mocks__)[\\/]`);
+}
+/**
+ * Checks whether a file path matches a test file pattern.
+ *
+ * @param filePath the file path to test.
+ * @param extensions the allowed test file extensions.
+ * @returns true when the path looks like a test file.
+ */
+function isTestFile(filePath, extensions) {
+    return testFilePattern(extensions).test(filePath);
+}
+/**
+ * Checks whether a file path looks test-related.
+ *
+ * @param filePath the file path to test.
+ * @param extensions the allowed test file extensions.
+ * @returns true when the path looks test-related.
+ */
+function isTestRelatedFile(filePath, extensions) {
+    return testRelatedFilePattern(extensions).test(filePath);
+}

package/cjs/helpers/type-origin.js

@@ -0,0 +1,82 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.classifyTypesByOrigin = classifyTypesByOrigin;
+/*
+ * SonarQube JavaScript Plugin
+ * Copyright (C) SonarSource Sàrl
+ * mailto:info AT sonarsource DOT com
+ *
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the Sonar Source-Available License for more details.
+ *
+ * You should have received a copy of the Sonar Source-Available License
+ * along with this program; if not, see https://sonarsource.com/license/ssal/
+ */
+const typescript_1 = __importDefault(require("typescript"));
+/**
+ * Partitions the syntactic members of a type annotation into "internal"
+ * (user-writable in this project) and "external" (declared in node_modules
+ * or in the TypeScript default lib).
+ *
+ * Operates on the syntactic AST node, not on a resolved `ts.Type`. Returning
+ * the original AST nodes lets callers produce locations, suggestions, or
+ * fixes targeting exactly what the user wrote.
+ *
+ * Classification rules per top-level member:
+ * - Keyword / literal types -> internal (the user wrote them directly).
+ * - TSTypeReference -> resolves the type name to a symbol and inspects its
+ *   declarations. A reference is external only when ALL declarations live in
+ *   files that satisfy `isSourceFileFromExternalLibrary` or
+ *   `isSourceFileDefaultLibrary`. Any local declaration (declaration-merging
+ *   escape hatch) makes the reference internal.
+ * - Any other composite constructor (TSIntersectionType, TSArrayType,
+ *   TSTypeLiteral, TSConditionalType, ...) -> internal at the top level. We
+ *   do not recurse; callers can if they need to.
+ *
+ * Known limitation: alias chains are not followed. If the user re-aliases an
+ * external type locally (e.g. `type Inner = ReactNode`), the local alias is
+ * internal because the user has a place to edit.
+ */
+function classifyTypesByOrigin(typeNode, services) {
+    const members = typeNode.type === 'TSUnionType' ? typeNode.types : [typeNode];
+    const result = { internal: [], external: [] };
+    for (const member of members) {
+        if (isExternalMember(member, services)) {
+            result.external.push(member);
+        }
+        else {
+            result.internal.push(member);
+        }
+    }
+    return result;
+}
+function isExternalMember(member, services) {
+    if (member.type !== 'TSTypeReference') {
+        return false;
+    }
+    const checker = services.program.getTypeChecker();
+    const tsNode = services.esTreeNodeToTSNodeMap.get(member);
+    let symbol = checker.getSymbolAtLocation(tsNode.typeName);
+    // Imported names resolve to a local alias symbol pointing at the import
+    // statement; without following the alias, external imports would look local.
+    if (symbol && symbol.flags & typescript_1.default.SymbolFlags.Alias) {
+        symbol = checker.getAliasedSymbol(symbol);
+    }
+    if (!symbol?.declarations?.length) {
+        return false;
+    }
+    const program = services.program;
+    return symbol.declarations.every(decl => {
+        const sourceFile = decl.getSourceFile();
+        return (program.isSourceFileFromExternalLibrary(sourceFile) ||
+            program.isSourceFileDefaultLibrary(sourceFile));
+    });
+}

package/cjs/helpers/type.js

@@ -17,6 +17,8 @@ exports.isUndefinedOrNull = isUndefinedOrNull;
 exports.isThenable = isThenable;
 exports.isThenableOrVoidUnion = isThenableOrVoidUnion;
 exports.isAny = isAny;
+exports.areMutuallyAssignableTypes = areMutuallyAssignableTypes;
+exports.areSameTypeDeclarations = areSameTypeDeclarations;
 exports.isGenericType = isGenericType;
 exports.getTypeFromTreeNode = getTypeFromTreeNode;
 exports.getTypeAsString = getTypeAsString;
@@ -26,6 +28,7 @@ exports.isArrayLikeType = isArrayLikeType;
 exports.isStringArray = isStringArray;
 exports.isNumberArray = isNumberArray;
 exports.isBigIntArray = isBigIntArray;
+exports.isBooleanArray = isBooleanArray;
 exports.isTypeAlias = isTypeAlias;
 exports.isBooleanTrueType = isBooleanTrueType;
 exports.isBooleanType = isBooleanType;
@@ -36,6 +39,9 @@ exports.isIterable = isIterable;
 exports.getFunctionParameterCount = getFunctionParameterCount;
 const typescript_1 = __importDefault(require("typescript"));
 const ast_js_1 = require("./ast.js");
+/**
+ * Returns true when `node` resolves to the built-in `Array` type.
+ */
 function isArray(node, services) {
     const type = getTypeFromTreeNode(node, services);
     return type.symbol?.name === 'Array';
@@ -95,30 +101,51 @@ function isTypedArray(node, services) {
     const type = getTypeFromTreeNode(node, services);
     return TYPED_ARRAY_TYPES.has(type.symbol?.name);
 }
+/**
+ * Returns true when `node` resolves to a string-like type.
+ */
 function isString(node, services) {
     const checker = services.program.getTypeChecker();
     const typ = checker.getTypeAtLocation(services.esTreeNodeToTSNodeMap.get(node));
     return (typ.getFlags() & typescript_1.default.TypeFlags.StringLike) !== 0;
 }
+/**
+ * Returns true when `node` resolves to a number-like type.
+ */
 function isNumber(node, services) {
     const checker = services.program.getTypeChecker();
     const typ = checker.getTypeAtLocation(services.esTreeNodeToTSNodeMap.get(node));
     return (typ.getFlags() & typescript_1.default.TypeFlags.NumberLike) !== 0;
 }
+/**
+ * Returns true when `type` is bigint-like.
+ */
 function isBigIntType(type) {
     return (type.getFlags() & typescript_1.default.TypeFlags.BigIntLike) !== 0;
 }
+/**
+ * Returns true when `type` is number-like.
+ */
 function isNumberType(type) {
     return (type.getFlags() & typescript_1.default.TypeFlags.NumberLike) !== 0;
 }
+/**
+ * Returns true when `type` is string-like.
+ */
 function isStringType(type) {
     return (type.flags & typescript_1.default.TypeFlags.StringLike) > 0 || type.symbol?.name === 'String';
 }
+/**
+ * Returns true when `node` resolves to a function type.
+ */
 function isFunction(node, services) {
     const checker = services.program.getTypeChecker();
     const type = checker.getTypeAtLocation(services.esTreeNodeToTSNodeMap.get(node));
     return type.symbol && (type.symbol.flags & typescript_1.default.SymbolFlags.Function) !== 0;
 }
+/**
+ * Returns true when `node` resolves to a union type.
+ */
 function isUnion(node, services) {
     const checker = services.program.getTypeChecker();
     const type = checker.getTypeAtLocation(services.esTreeNodeToTSNodeMap.get(node));
@@ -133,11 +160,17 @@ function isUnion(node, services) {
 function getUnionTypes(type) {
     return type.isUnion() ? type.types : [type];
 }
+/**
+ * Returns true when `node` resolves to `undefined`, `null`, or a union containing either.
+ */
 function isUndefinedOrNull(node, services) {
     const checker = services.program.getTypeChecker();
     const typ = checker.getTypeAtLocation(services.esTreeNodeToTSNodeMap.get(node));
     return ((typ.getFlags() & typescript_1.default.TypeFlags.Undefined) !== 0 || (typ.getFlags() & typescript_1.default.TypeFlags.Null) !== 0);
 }
+/**
+ * Returns true when `node` resolves to a thenable type.
+ */
 function isThenable(node, services) {
     const mapped = services.esTreeNodeToTSNodeMap.get(node);
     const checker = services.program.getTypeChecker();
@@ -174,9 +207,102 @@ function hasThenMethod(type, checker) {
     const thenType = checker.getTypeOfSymbol(thenProperty);
     return thenType.getCallSignatures().length > 0;
 }
+/**
+ * Returns true when `type` is exactly `any`.
+ */
 function isAny(type) {
     return type.flags === typescript_1.default.TypeFlags.Any;
 }
+/**
+ * Returns true when both types are specific enough to compare (neither `any`
+ * nor `unknown`) and are mutually assignable.
+ *
+ * Mutual assignability is stricter than symbol equality for generic aliases:
+ * `Props<User>` and `Props<Product>` share the same alias symbol, but they are
+ * not mutually assignable and therefore do not represent the same effective type.
+ */
+function areMutuallyAssignableTypes(checker, left, right) {
+    if (!left || !right || isAnyOrUnknownType(left) || isAnyOrUnknownType(right)) {
+        return false;
+    }
+    // @ts-ignore -- isTypeAssignableTo is a private TypeScript API
+    return checker.isTypeAssignableTo(left, right) && checker.isTypeAssignableTo(right, left);
+}
+/**
+ * Returns true when both types come from the same named declaration and, for
+ * generic declarations, are instantiated with the same type arguments.
+ *
+ * The comparison has two steps:
+ * 1. the declarations must resolve to the same symbol
+ * 2. each type argument must match through `areSameTypeArguments(...)`
+ *
+ * That helper can call back into this function for named type arguments, so
+ * generic comparisons recurse through nested declarations.
+ *
+ * This is intentionally stricter than structural equality: `Props<User>` and
+ * `Props<Product>` are different, and `Props<User>` also stays different from
+ * `Props<{ id: string }>` even if the shapes happen to match.
+ */
+function areSameTypeDeclarations(checker, left, right) {
+    if (!left || !right || isAnyOrUnknownType(left) || isAnyOrUnknownType(right)) {
+        return false;
+    }
+    const leftSymbol = getComparableDeclaredTypeSymbol(left);
+    const rightSymbol = getComparableDeclaredTypeSymbol(right);
+    if (!leftSymbol || leftSymbol !== rightSymbol) {
+        return false;
+    }
+    const leftArgs = getDeclaredTypeArguments(left, checker);
+    const rightArgs = getDeclaredTypeArguments(right, checker);
+    return (leftArgs.length === rightArgs.length &&
+        leftArgs.every((argument, index) => areSameTypeArguments(checker, argument, rightArgs[index])));
+}
+function areSameTypeArguments(checker, left, right) {
+    if (!left || !right) {
+        return false;
+    }
+    if (isAnyOrUnknownType(left) || isAnyOrUnknownType(right)) {
+        return (isAnyOrUnknownType(left) &&
+            isAnyOrUnknownType(right) &&
+            checker.typeToString(left) === checker.typeToString(right));
+    }
+    const leftSymbol = getComparableDeclaredTypeSymbol(left);
+    const rightSymbol = getComparableDeclaredTypeSymbol(right);
+    if (leftSymbol || rightSymbol) {
+        // Keep named type arguments distinct from anonymous structural literals.
+        return leftSymbol !== undefined && leftSymbol === rightSymbol
+            ? areSameTypeDeclarations(checker, left, right)
+            : false;
+    }
+    // Primitives, unions, tuples, and anonymous object literals do not have a
+    // stable declared type symbol, so compare their effective instantiated form.
+    return checker.typeToString(left) === checker.typeToString(right);
+}
+function isAnyOrUnknownType(type) {
+    return (type.flags & (typescript_1.default.TypeFlags.Any | typescript_1.default.TypeFlags.Unknown)) !== 0;
+}
+/**
+ * Returns the symbol to use for declaration-based comparisons.
+ *
+ * Anonymous type literals such as `{ id: string }` are intentionally excluded:
+ * their `TypeLiteral` symbols do not represent stable declaration identities.
+ * Named interfaces and type aliases are still kept because we prefer
+ * `aliasSymbol` over the underlying `TypeLiteral` symbol.
+ */
+function getComparableDeclaredTypeSymbol(type) {
+    const symbol = type.aliasSymbol ?? type.symbol;
+    return symbol && (symbol.flags & typescript_1.default.SymbolFlags.TypeLiteral) === 0 ? symbol : undefined;
+}
+function getDeclaredTypeArguments(type, checker) {
+    if (type.aliasTypeArguments?.length) {
+        return type.aliasTypeArguments;
+    }
+    return isTypeReference(type) ? checker.getTypeArguments(type) : [];
+}
+function isTypeReference(type) {
+    return ((type.flags & typescript_1.default.TypeFlags.Object) !== 0 &&
+        (type.objectFlags & typescript_1.default.ObjectFlags.Reference) !== 0);
+}
 /**
  * Checks if a node has a generic type like:
  *
@@ -192,18 +318,30 @@ function isGenericType(node, services) {
     const type = getTypeFromTreeNode(node, services);
     return type.isTypeParameter();
 }
+/**
+ * Returns the TypeScript type resolved at `node`.
+ */
 function getTypeFromTreeNode(node, services) {
     const checker = services.program.getTypeChecker();
     return checker.getTypeAtLocation(services.esTreeNodeToTSNodeMap.get(node));
 }
+/**
+ * Returns the widened string representation of the type resolved at `node`.
+ */
 function getTypeAsString(node, services) {
     const { typeToString, getBaseTypeOfLiteralType } = services.program.getTypeChecker();
     return typeToString(getBaseTypeOfLiteralType(getTypeFromTreeNode(node, services)));
 }
+/**
+ * Returns the symbol resolved at `node`, if any.
+ */
 function getSymbolAtLocation(node, services) {
     const checker = services.program.getTypeChecker();
     return checker.getSymbolAtLocation(services.esTreeNodeToTSNodeMap.get(node));
 }
+/**
+ * Returns the resolved call signature for the call-like expression at `node`.
+ */
 function getSignatureFromCallee(node, services) {
     const checker = services.program.getTypeChecker();
     return checker.getResolvedSignature(services.esTreeNodeToTSNodeMap.get(node));
@@ -251,6 +389,14 @@ function isNumberArray(type, services) {
 function isBigIntArray(type, services) {
     return isArrayElementTypeMatching(type, services, isBigIntType);
 }
+/**
+ * Test if the provided type is an array of booleans.
+ * @param type A TypeScript type.
+ * @param services The services used to get access to the TypeScript type checker
+ */
+function isBooleanArray(type, services) {
+    return isArrayElementTypeMatching(type, services, isBooleanType);
+}
 function isArrayElementTypeMatching(type, services, predicate) {
     const checker = services.program.getTypeChecker();
     if (!isArrayType(type, services)) {
@@ -284,18 +430,33 @@ function isTypeAlias(node, context) {
 function isBooleanLiteralType(type) {
     return type.flags === typescript_1.default.TypeFlags.BooleanLiteral;
 }
+/**
+ * Returns true when `type` is the boolean literal `true`.
+ */
 function isBooleanTrueType(type) {
     return isBooleanLiteralType(type) && type.intrinsicName === 'true';
 }
+/**
+ * Returns true when `type` is boolean-like.
+ */
 function isBooleanType({ flags }) {
-    return flags & typescript_1.default.TypeFlags.BooleanLike;
+    return (flags & typescript_1.default.TypeFlags.BooleanLike) !== 0;
 }
+/**
+ * Returns true when `type` is `null`, `undefined`, or a union containing either.
+ */
 function isNullOrUndefinedType({ flags }) {
     return flags & typescript_1.default.TypeFlags.Null || flags & typescript_1.default.TypeFlags.Undefined;
 }
+/**
+ * Returns true when `type` is object-like.
+ */
 function isObjectType({ flags }) {
     return flags & typescript_1.default.TypeFlags.Object;
 }
+/**
+ * Returns true when `node` exposes a callable member named `methodName`.
+ */
 function typeHasMethod(node, methodName, services) {
     const type = getTypeFromTreeNode(node, services);
     const property = type.getProperty(methodName);

package/cjs/helpers/vitest.js

@@ -3,15 +3,11 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isImported = isImported;
 exports.isAssertion = isAssertion;
 exports.isTSAssertion = isTSAssertion;
 const module_js_1 = require("./module.js");
 const module_ts_js_1 = require("./module-ts.js");
 const typescript_1 = __importDefault(require("typescript"));
-function isImported(context) {
-    return ((0, module_js_1.getRequireCalls)(context).some(r => r.arguments[0].type === 'Literal' && r.arguments[0].value === 'vitest') || (0, module_js_1.getImportDeclarations)(context).some(i => i.source.value === 'vitest'));
-}
 function isAssertion(context, node) {
     const fullyQualifiedName = extractFQNforCallExpression(context, node);
     return isFQNAssertion(fullyQualifiedName);