eslint-plugin-sonarjs 4.0.3 → 4.1.0

package/cjs/helpers/dependency-manifests/resolvers/package-json.js

@@ -0,0 +1,167 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.packageJsonManifestResolver = void 0;
+const files_js_1 = require("../../files.js");
+const index_js_1 = require("../index.js");
+const closest_js_1 = require("../../find-up/closest.js");
+const helpers_js_1 = require("./helpers.js");
+const parse_js_1 = require("../parse.js");
+const parsed_dependency_files_js_1 = require("../parsed-dependency-files.js");
+exports.packageJsonManifestResolver = {
+    resolve(dir, topDir, fileSystem) {
+        const packageJson = (0, helpers_js_1.getManifestFileInDir)(index_js_1.PACKAGE_JSON, dir, topDir, fileSystem);
+        if (!packageJson) {
+            return [];
+        }
+        let parsedPackageJson = (0, parsed_dependency_files_js_1.parsePackageJson)(packageJson) ?? {};
+        let catalogSource = undefined;
+        const closestParent = findClosestParentPackageJsonWithCatalogs(dir, topDir, fileSystem);
+        if (closestParent) {
+            // If the closest parent package.json has catalogs defined, we use it as the catalog source for resolving catalog references.
+            const workspaces = Array.isArray(closestParent.workspaces)
+                ? undefined
+                : closestParent.workspaces;
+            catalogSource = {
+                catalog: workspaces?.catalog ?? closestParent.catalog,
+                catalogs: workspaces?.catalogs ?? closestParent.catalogs,
+            };
+        }
+        else {
+            // No parent package.json with catalogs found, we check if there's a pnpm workspace file that we can use as a catalog source.
+            const pnpmWorkspaceFile = closest_js_1.closestPatternCache
+                .get(index_js_1.PNPM_WORKSPACE_YAML, fileSystem)
+                .get(topDir)
+                .get(dir);
+            const parsedPnpmWorkspace = pnpmWorkspaceFile
+                ? (0, parsed_dependency_files_js_1.parsePnpmWorkspace)(pnpmWorkspaceFile)
+                : undefined;
+            if (parsedPnpmWorkspace) {
+                parsedPackageJson = injectWorkspacePackages(parsedPackageJson, parsedPnpmWorkspace);
+                catalogSource = parsedPnpmWorkspace;
+            }
+        }
+        parsedPackageJson = resolveCatalogReferences(parsedPackageJson, catalogSource);
+        // Match Node's resolution: explicit "module" is ESM, anything else (including
+        // missing "type") is CommonJS.
+        const moduleType = parsedPackageJson.type === 'module' ? 'module' : 'commonjs';
+        return [
+            {
+                type: 'package-json',
+                manifest: parsedPackageJson,
+                dependencies: buildDependencies(parsedPackageJson),
+                moduleType,
+            },
+        ];
+    },
+};
+function buildDependencies(packageJson) {
+    const dependencies = new Map();
+    const fieldsToVisit = [
+        'name',
+        'dependencies',
+        'devDependencies',
+        'peerDependencies',
+        'optionalDependencies',
+        '_moduleAliases',
+        'workspaces',
+    ];
+    for (const field of fieldsToVisit) {
+        if (!packageJson[field]) {
+            continue;
+        }
+        if (field === 'name') {
+            (0, parse_js_1.addDependencies)(dependencies, { [packageJson[field]]: '*' });
+            continue;
+        }
+        if (field === 'workspaces') {
+            (0, parse_js_1.addDependenciesArray)(dependencies, Array.isArray(packageJson[field])
+                ? packageJson[field]
+                : (packageJson[field]?.packages ?? []));
+            continue;
+        }
+        (0, parse_js_1.addDependencies)(dependencies, packageJson[field]);
+    }
+    return dependencies;
+}
+function resolveCatalogReferences(packageJson, catalogSource) {
+    const depFields = [
+        'dependencies',
+        'devDependencies',
+        'peerDependencies',
+        'optionalDependencies',
+    ];
+    const modifiedPackageJson = { ...packageJson };
+    for (const field of depFields) {
+        const deps = packageJson[field];
+        if (!deps) {
+            continue;
+        }
+        const resolvedDeps = {};
+        for (const [depName, depVersion] of Object.entries(deps)) {
+            if (typeof depVersion === 'string' && depVersion.startsWith('catalog:')) {
+                const catalogName = depVersion.slice('catalog:'.length).trim() || 'default';
+                const resolvedDep = catalogName === 'default'
+                    ? catalogSource?.catalog?.[depName]
+                    : catalogSource?.catalogs?.[catalogName]?.[depName];
+                resolvedDeps[depName] = resolvedDep ?? depVersion;
+                !resolvedDep &&
+                    console.debug(`Dependency "${depName}" could not be resolved for catalog "${catalogName}"`);
+            }
+            else {
+                resolvedDeps[depName] = depVersion ?? '';
+            }
+        }
+        modifiedPackageJson[field] = resolvedDeps;
+    }
+    return modifiedPackageJson;
+}
+function injectWorkspacePackages(packageJson, pnpmWorkspace) {
+    if (!pnpmWorkspace.packages || packageJson.workspaces) {
+        return packageJson;
+    }
+    return {
+        ...packageJson,
+        workspaces: pnpmWorkspace.packages,
+    };
+}
+/**
+ * Find the closest parent package.json with catalogs defined.
+ * @param dir Directory to start the search from
+ * @param topDir Top directory to stop the search at
+ * @param fileSystem Filesystem to use for the search
+ * @returns The closest parent package.json with catalogs, or undefined if no package.json with catalogs is found
+ */
+function findClosestParentPackageJsonWithCatalogs(dir, topDir, fileSystem) {
+    if (dir === topDir) {
+        // No point in searching for parent package.json if we're already at the top directory.
+        return undefined;
+    }
+    let currentDir = (0, helpers_js_1.getParentDirPath)(dir);
+    const cache = closest_js_1.closestPatternCache.get(index_js_1.PACKAGE_JSON, fileSystem).get(topDir);
+    while (currentDir !== null) {
+        const file = cache.get(currentDir);
+        if (!file) {
+            return undefined;
+        }
+        const parsed = (0, parsed_dependency_files_js_1.parsePackageJson)(file);
+        if (parsed && hasCatalogs(parsed)) {
+            return parsed;
+        }
+        const fileDir = (0, files_js_1.dirnamePath)(file.filePath);
+        if (fileDir === topDir) {
+            return undefined;
+        }
+        currentDir = (0, helpers_js_1.getParentDirPath)(fileDir);
+    }
+    return undefined;
+}
+function hasCatalogs(packageJson) {
+    if (packageJson.catalog || packageJson.catalogs) {
+        return true;
+    }
+    const { workspaces } = packageJson;
+    if (workspaces && !Array.isArray(workspaces)) {
+        return !!(workspaces.catalog || workspaces.catalogs);
+    }
+    return false;
+}

package/cjs/helpers/dependency-manifests/resolvers/types.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFINITELY_TYPED = void 0;
+exports.DEFINITELY_TYPED = '@types/';

package/cjs/helpers/files.js

@@ -5,8 +5,11 @@ exports.stripBOM = stripBOM;
 exports.normalizePath = normalizePath;
 exports.normalizeToAbsolutePath = normalizeToAbsolutePath;
 exports.isRoot = isRoot;
+exports.assertNestedPath = assertNestedPath;
+exports.getPathRoot = getPathRoot;
 exports.isAbsolutePath = isAbsolutePath;
 exports.dirnamePath = dirnamePath;
+exports.relativeToAncestorPath = relativeToAncestorPath;
 exports.joinPaths = joinPaths;
 exports.basenamePath = basenamePath;
 /*
@@ -95,6 +98,25 @@ function isParseResultRoot(result) {
 function isRoot(file) {
     return isParseResultRoot((0, win32_1.parse)(file)) || isParseResultRoot((0, posix_1.parse)(file));
 }
+function assertNestedPath(from, topDir) {
+    const fromSanitized = from.endsWith('/') ? from : from + '/';
+    const topDirSanitized = topDir.endsWith('/') ? topDir : topDir + '/';
+    if (!fromSanitized.startsWith(topDirSanitized)) {
+        throw new Error(`"${from}" is not nested under topDir "${topDir}"`);
+    }
+}
+/**
+ * Returns the filesystem root that contains the given absolute path.
+ * Examples: '/a/b' -> '/', 'C:/a/b' -> 'C:/', 'D:/foo' -> 'D:/'.
+ * Used as a cross-platform "no upper bound" sentinel for find-up callers.
+ */
+function getPathRoot(filePath) {
+    const winRoot = (0, win32_1.parse)(filePath).root;
+    if (winRoot) {
+        return toUnixPath(winRoot);
+    }
+    return exports.ROOT_PATH;
+}
 function isAbsolutePath(path) {
     // Check for Windows drive letter (e.g., 'c:', 'C:', 'D:')
     // Node's isAbsolute considers 'c:' as relative (drive-relative), but we treat it as absolute
@@ -112,6 +134,13 @@ function isAbsolutePath(path) {
 function dirnamePath(filePath) {
     return (0, posix_1.dirname)(filePath);
 }
+function relativeToAncestorPath(filePath, topDir) {
+    const topDirPrefix = topDir.endsWith('/') ? topDir : `${topDir}/`;
+    if (filePath === topDir) {
+        return '';
+    }
+    return filePath.startsWith(topDirPrefix) ? filePath.slice(topDirPrefix.length) : undefined;
+}
 /**
  * Type-safe path join that preserves the NormalizedAbsolutePath brand.
  * Joins path segments using posix separators.

package/cjs/helpers/find-up/all-in-parent-dirs.js

@@ -18,6 +18,7 @@ exports.patternInParentsCache = new cache_js_1.ComputedCache((pattern, filesyste
                 // handle path.dirname returning "." in windows
                 return [];
             }
+            (0, files_js_1.assertNestedPath)(from, topDir);
             if (!(0, files_js_1.isRoot)(from) && from !== topDir) {
                 const parent = (0, files_js_1.dirnamePath)(from);
                 return [...readDir.get(from), ...newCache.get(parent)];

package/cjs/helpers/find-up/closest.js

@@ -34,6 +34,7 @@ exports.closestPatternCache = new cache_js_1.ComputedCache((pattern, filesystem
                 // handle path.dirname returning "." in windows
                 return undefined;
             }
+            (0, files_js_1.assertNestedPath)(from, topDir);
             const matchingFiles = readDir.get(from);
             if (matchingFiles.length > 0) {
                 return matchingFiles[0];

package/cjs/helpers/find-up/find-minimatch.js

@@ -28,8 +28,8 @@ exports.MinimatchCache = new cache_js_1.ComputedCache((matcher, filesystem = nod
                     }
                     if (stats.isFile()) {
                         files.push({
-                            path: fullEntryPath,
-                            content: filesystem.readFileSync(fullEntryPath),
+                            filePath: fullEntryPath,
+                            fileContent: filesystem.readFileSync(fullEntryPath, 'utf8'),
                         });
                     }
                 }

package/cjs/helpers/generate-meta.js

@@ -20,7 +20,7 @@ function generateMeta(sonarMeta, ruleMeta) {
     };
     // If rules contains default options, we will augment them with our defaults.
     if (ruleMeta?.defaultOptions) {
-        metadata.defaultOptions = (0, lodash_merge_1.default)(ruleMeta.defaultOptions, sonarMeta.meta.defaultOptions);
+        metadata.defaultOptions = (0, lodash_merge_1.default)([], ruleMeta.defaultOptions, sonarMeta.meta.defaultOptions);
     }
     // RSPEC metadata can include fixable also for rules with suggestions, because RSPEC doesn't differentiate between fix
     // and suggestion like ESLint does. That's why we set fixable using ruleMeta

package/cjs/helpers/mocha-style-test-frameworks.js

@@ -0,0 +1,132 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PLAYWRIGHT_DESCRIBE_FOCUS_MODIFIER = exports.PLAYWRIGHT_DESCRIBE_MODIFIERS = exports.PLAYWRIGHT_TEST_MODIFIERS = exports.SUITE_FUNCTION_NAMES = exports.TEST_FUNCTION_NAMES = exports.SUPPORTED_TEST_FRAMEWORKS = void 0;
+exports.isMochaTestConstruct = isMochaTestConstruct;
+exports.isConcreteMochaTestModifier = isConcreteMochaTestModifier;
+exports.getMochaCalleeParts = getMochaCalleeParts;
+exports.getMochaConstructName = getMochaConstructName;
+exports.hasCallback = hasCallback;
+exports.getStaticTitle = getStaticTitle;
+exports.getPlaywrightTestQualifiers = getPlaywrightTestQualifiers;
+exports.getPlaywrightDescribeQualifiers = getPlaywrightDescribeQualifiers;
+const ast_js_1 = require("./ast.js");
+const module_js_1 = require("./module.js");
+exports.SUPPORTED_TEST_FRAMEWORKS = ['jest', 'mocha', 'vitest', '@playwright/test'];
+const MOCHA_STYLE_TEST_FRAMEWORKS = new Set(['jest', 'mocha', 'vitest']);
+exports.TEST_FUNCTION_NAMES = ['it', 'specify', 'test'];
+exports.SUITE_FUNCTION_NAMES = ['describe', 'context', 'suite'];
+const COMMON_MOCHA_TEST_MODIFIERS = new Set(['only', 'concurrent']);
+const JEST_TEST_MODIFIERS = new Set(['failing']);
+const VITEST_TEST_MODIFIERS = new Set(['sequential']);
+const PLAYWRIGHT_TEST_FQN = '@playwright.test.test';
+exports.PLAYWRIGHT_TEST_MODIFIERS = new Set(['only', 'fail']);
+exports.PLAYWRIGHT_DESCRIBE_MODIFIERS = new Set(['parallel', 'serial']);
+exports.PLAYWRIGHT_DESCRIBE_FOCUS_MODIFIER = 'only';
+function isMochaTestConstruct(context, node, constructs) {
+    const calleeParts = getMochaCalleeParts(node.callee);
+    if (calleeParts === undefined) {
+        return false;
+    }
+    const constructName = getMochaConstructName(context, calleeParts.base);
+    if (constructName === undefined || !constructs.includes(constructName)) {
+        return false;
+    }
+    return calleeParts.modifiers.every(modifier => isConcreteMochaTestModifier(context, modifier));
+}
+function isConcreteMochaTestModifier(context, modifier) {
+    return (COMMON_MOCHA_TEST_MODIFIERS.has(modifier) ||
+        (JEST_TEST_MODIFIERS.has(modifier) && isTestFrameworkActive(context, 'jest')) ||
+        (VITEST_TEST_MODIFIERS.has(modifier) && isTestFrameworkActive(context, 'vitest')));
+}
+function isTestFrameworkActive(context, framework) {
+    return (0, module_js_1.importsOrDependsOnModule)(context, [framework], [framework]);
+}
+function getMochaCalleeParts(node) {
+    const modifiers = [];
+    let current = node;
+    while (true) {
+        if (current.type === 'CallExpression') {
+            current = current.callee;
+        }
+        else if (isQualifyingMember(current)) {
+            modifiers.unshift(current.property.name);
+            current = current.object;
+        }
+        else {
+            break;
+        }
+    }
+    return current.type === 'Identifier' ? { base: current, modifiers } : undefined;
+}
+function collectMemberChain(node) {
+    const qualifiers = [];
+    let current = node;
+    while (isQualifyingMember(current)) {
+        qualifiers.unshift(current.property.name);
+        current = current.object;
+    }
+    return { base: current, qualifiers };
+}
+function isQualifyingMember(node) {
+    return node.type === 'MemberExpression' && !node.computed && (0, ast_js_1.isIdentifier)(node.property);
+}
+function getMochaConstructName(context, identifier) {
+    const variable = (0, ast_js_1.getVariableFromScope)(context.sourceCode.getScope(identifier), identifier.name);
+    if (variable?.defs.some(def => def.type === 'ImportBinding' || isSupportedRequireBinding(def.node))) {
+        return getMochaConstructNameFromFqn((0, module_js_1.getFullyQualifiedName)(context, identifier));
+    }
+    return variable == null || variable.defs.length === 0 ? identifier.name : undefined;
+}
+function getMochaConstructNameFromFqn(fqn) {
+    const parts = fqn?.split('.');
+    if (parts?.length !== 2) {
+        return undefined;
+    }
+    const [framework, constructName] = parts;
+    return MOCHA_STYLE_TEST_FRAMEWORKS.has(framework) ? constructName : undefined;
+}
+function isSupportedRequireBinding(node) {
+    if (node.type !== 'VariableDeclarator' || node.init == null) {
+        return false;
+    }
+    const requireCall = getRequireCall(node.init);
+    const moduleName = requireCall?.arguments[0];
+    return (moduleName?.type === 'Literal' &&
+        typeof moduleName.value === 'string' &&
+        exports.SUPPORTED_TEST_FRAMEWORKS.includes(moduleName.value));
+}
+function getRequireCall(node) {
+    if (isRequireCall(node)) {
+        return node;
+    }
+    if (node.type === 'MemberExpression') {
+        return getRequireCall(node.object);
+    }
+    return undefined;
+}
+function isRequireCall(node) {
+    return (node.type === 'CallExpression' &&
+        node.callee.type === 'Identifier' &&
+        node.callee.name === 'require');
+}
+function hasCallback(node) {
+    return node.arguments.some(argument => ast_js_1.FUNCTION_NODES.includes(argument.type));
+}
+function getStaticTitle(node) {
+    if ((0, ast_js_1.isStringLiteral)(node)) {
+        return node.value;
+    }
+    if ((0, ast_js_1.isStaticTemplateLiteral)(node)) {
+        const value = node.quasis[0].value;
+        return value.cooked ?? value.raw;
+    }
+    return undefined;
+}
+function getPlaywrightTestQualifiers(context, node) {
+    const { base, qualifiers } = collectMemberChain(node);
+    return (0, module_js_1.getFullyQualifiedName)(context, base) === PLAYWRIGHT_TEST_FQN ? qualifiers : undefined;
+}
+function getPlaywrightDescribeQualifiers(node) {
+    const { base, qualifiers } = collectMemberChain(node);
+    return (0, ast_js_1.isIdentifier)(base, 'test') ? qualifiers : undefined;
+}

package/cjs/helpers/mocha.js

@@ -4,17 +4,18 @@ exports.isTestConstruct = isTestConstruct;
 exports.extractTestCase = extractTestCase;
 exports.isTestCase = isTestCase;
 exports.isDescribeCase = isDescribeCase;
+exports.isLifecycleHook = isLifecycleHook;
 const ast_js_1 = require("./ast.js");
-const TEST_CONSTRUCTS = [
-    'describe',
-    'context',
-    'it',
-    'specify',
+const LIFECYCLE_HOOK_CONSTRUCTS = [
     'before',
     'after',
+    'beforeAll',
+    'afterAll',
     'beforeEach',
     'afterEach',
 ];
+const TEST_CONSTRUCTS = ['describe', 'context', 'it', 'specify', ...LIFECYCLE_HOOK_CONSTRUCTS];
+const TEST_CASE_CONSTRUCTS = ['it', 'specify', 'test'];
 function isTestConstruct(node, constructs = TEST_CONSTRUCTS) {
     return constructs.some(construct => {
         return (node.type === 'CallExpression' &&
@@ -41,7 +42,7 @@ function extractTestCase(node) {
  * @returns
  */
 function isTestCase(node) {
-    return isTestConstruct(node, ['it', 'specify']);
+    return isTestConstruct(node, TEST_CASE_CONSTRUCTS);
 }
 /**
  * returns true if the node is a describe block
@@ -50,5 +51,14 @@ function isTestCase(node) {
  * @returns
  */
 function isDescribeCase(node) {
-    return isTestConstruct(node, ['describe']);
+    return isTestConstruct(node, ['describe', 'context']);
+}
+/**
+ * returns true if the node is a lifecycle hook
+ *
+ * @param node
+ * @returns
+ */
+function isLifecycleHook(node) {
+    return isTestConstruct(node, LIFECYCLE_HOOK_CONSTRUCTS);
 }

package/cjs/helpers/module.js

@@ -1,46 +1,136 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isESModule = isESModule;
 exports.getImportDeclarations = getImportDeclarations;
-exports.getRequireCalls = getRequireCalls;
+exports.clearFileCaches = clearFileCaches;
+exports.getCurrentFileImports = getCurrentFileImports;
+exports.importsModule = importsModule;
+exports.importsOrDependsOnModule = importsOrDependsOnModule;
 exports.isRequire = isRequire;
 exports.getFullyQualifiedName = getFullyQualifiedName;
 exports.removeNodePrefixIfExists = removeNodePrefixIfExists;
 exports.reduceToIdentifier = reduceToIdentifier;
 const ast_js_1 = require("./ast.js");
+const dependencies_js_1 = require("./dependency-manifests/dependencies.js");
+function getImportDeclarations(context) {
+    return context.sourceCode.ast.body.filter(node => node.type === 'ImportDeclaration');
+}
 /**
- * Checks if the current file is an ES module based on sourceType.
+ * Cache for storing the set of all module names imported or required in the file currently being analyzed.
+ * This set is only needed while the current file is being analyzed.
  *
- * The parser sets sourceType based on file extension (.mjs/.cjs),
- * package.json "type" field, and ESLint configuration.
+ * Keyed by the `sourceCode` object reference rather than a boolean flag so that the cache
+ * self-invalidates when ESLint's RuleTester switches between test cases (each case gets a fresh
+ * SourceCode instance).
  */
-function isESModule(context) {
-    return context.sourceCode.ast.sourceType === 'module';
-}
-function getImportDeclarations(context) {
-    if (isESModule(context)) {
-        return context.sourceCode.ast.body.filter(node => node.type === 'ImportDeclaration');
+const CURRENT_FILE_IMPORTS = {
+    sourceCode: null,
+    imports: new Set(),
+};
+/**
+ * Compute the set of all module names imported or required
+ * in the file currently being analyzed (via import declarations, require(), or dynamic import()).
+ *
+ * Supported patterns:
+ * import foo from 'lodash';
+ * const lodash = require('lodash');
+ * const partition = require('lodash').partition;
+ * const lodash = import('lodash');
+ * const lodash = await import('lodash');
+ *
+ * Unsupported patterns (not stored in a variable):
+ * require('lodash');
+ * import('lodash').then(lodash => ...);
+ */
+function computeCurrentFileImports(sourceCode) {
+    if (CURRENT_FILE_IMPORTS.sourceCode === sourceCode) {
+        return;
     }
-    return [];
-}
-function getRequireCalls(context) {
-    const required = [];
-    const { scopeManager } = context.sourceCode;
-    for (const scope of scopeManager.scopes) {
+    CURRENT_FILE_IMPORTS.sourceCode = sourceCode;
+    CURRENT_FILE_IMPORTS.imports.clear();
+    for (const node of sourceCode.ast.body) {
+        if (node.type === 'ImportDeclaration' && typeof node.source.value === 'string') {
+            CURRENT_FILE_IMPORTS.imports.add(node.source.value);
+        }
+    }
+    for (const scope of sourceCode.scopeManager.scopes) {
         for (const variable of scope.variables) {
             for (const def of variable.defs) {
                 if (def.type === 'Variable' && def.node.init) {
-                    if (isRequire(def.node.init)) {
-                        required.push(def.node.init);
-                    }
-                    else if (def.node.init.type === 'MemberExpression' && isRequire(def.node.init.object)) {
-                        required.push(def.node.init.object);
+                    const name = getRequireModuleName(def.node.init) ?? getDynamicImportModuleName(def.node.init);
+                    if (name !== undefined) {
+                        CURRENT_FILE_IMPORTS.imports.add(name);
                     }
                 }
             }
         }
     }
-    return required;
+}
+/**
+ * Clears the caches related to the given source file
+ */
+function clearFileCaches() {
+    CURRENT_FILE_IMPORTS.sourceCode = null;
+    CURRENT_FILE_IMPORTS.imports.clear();
+    (0, dependencies_js_1.setCurrentFileInlineDependencies)(null);
+}
+function getCurrentFileImports(sourceCode) {
+    computeCurrentFileImports(sourceCode);
+    return CURRENT_FILE_IMPORTS.imports;
+}
+function getRequireModuleName(node) {
+    const requireCall = getRequireCall(node);
+    const moduleName = requireCall?.arguments[0];
+    if (moduleName?.type === 'Literal' && typeof moduleName.value === 'string') {
+        return moduleName.value;
+    }
+    return undefined;
+}
+function getRequireCall(node) {
+    if (isRequire(node)) {
+        return node;
+    }
+    if (node.type === 'MemberExpression' && isRequire(node.object)) {
+        return node.object;
+    }
+    return undefined;
+}
+function getDynamicImportModuleName(node) {
+    const dynamicImportExpression = getDynamicImportExpression(node);
+    const moduleName = dynamicImportExpression?.source;
+    if (moduleName?.type === 'Literal' && typeof moduleName.value === 'string') {
+        return moduleName.value;
+    }
+    return undefined;
+}
+function getDynamicImportExpression(node) {
+    if (node.type === 'ImportExpression') {
+        return node;
+    }
+    if (node.type === 'AwaitExpression' && node.argument.type === 'ImportExpression') {
+        return node.argument;
+    }
+    return undefined;
+}
+/**
+ * Checks if the file imports any of the specified modules, either via require() calls or import declarations.
+ */
+function importsModule(context, moduleNames) {
+    if (moduleNames.length === 0) {
+        return false;
+    }
+    const imports = getCurrentFileImports(context.sourceCode);
+    return moduleNames.some(name => imports.has(name));
+}
+/**
+ * Checks if at least one of the specified imports is imported (via import or require) in the file
+ * or if at least one of the specified dependencies is listed in the corresponding dependency manifest.
+ */
+function importsOrDependsOnModule(context, imports, dependencies) {
+    if (importsModule(context, imports)) {
+        return true;
+    }
+    const sanitizedDeps = (0, dependencies_js_1.getDependenciesSanitizePaths)(context);
+    return dependencies.some(dependency => sanitizedDeps.has(dependency));
 }
 function isRequire(node) {
     return (node.type === 'CallExpression' &&
@@ -257,6 +347,9 @@ function reduceTo(type, node, fqn = []) {
         else if (nodeToCheck.type === 'CallExpression' && !getModuleNameFromRequire(nodeToCheck)) {
             nodeToCheck = nodeToCheck.callee;
         }
+        else if (nodeToCheck.type === 'TaggedTemplateExpression') {
+            nodeToCheck = nodeToCheck.tag;
+        }
         else if (nodeToCheck.type === 'NewExpression') {
             nodeToCheck = nodeToCheck.callee;
         }

package/cjs/helpers/numbers.js

@@ -0,0 +1,62 @@
+"use strict";
+/*
+ * 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/
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isExactlyRepresentableAsBinaryFraction = isExactlyRepresentableAsBinaryFraction;
+exports.isExactlyRepresentableIntegerDivision = isExactlyRepresentableIntegerDivision;
+exports.greatestCommonDivisor = greatestCommonDivisor;
+exports.isPowerOfTwo = isPowerOfTwo;
+const decimalLiteralPattern = /^(\d*)(?:\.(\d*))?(?:e([+-]?\d+))?$/u;
+function isExactlyRepresentableAsBinaryFraction(raw) {
+    const match = decimalLiteralPattern.exec(raw);
+    if (!match) {
+        return false;
+    }
+    const [, integerPart, fractionalPart = '', exponentPart] = match;
+    const digits = `${integerPart}${fractionalPart}`;
+    if (digits === '') {
+        return false;
+    }
+    const exponent = Number(exponentPart ?? 0) - fractionalPart.length;
+    const numerator = BigInt(digits);
+    if (numerator === 0n || exponent >= 0) {
+        return true;
+    }
+    const denominator = 10n ** BigInt(-exponent);
+    const reducedDenominator = denominator / greatestCommonDivisor(numerator, denominator);
+    return isPowerOfTwo(reducedDenominator);
+}
+function isExactlyRepresentableIntegerDivision(leftValue, rightValue) {
+    if (!Number.isSafeInteger(leftValue) || !Number.isSafeInteger(rightValue) || rightValue === 0) {
+        return false;
+    }
+    const numerator = BigInt(Math.abs(leftValue));
+    const denominator = BigInt(Math.abs(rightValue));
+    const reducedDenominator = denominator / greatestCommonDivisor(numerator, denominator);
+    return isPowerOfTwo(reducedDenominator);
+}
+function greatestCommonDivisor(left, right) {
+    let a = left;
+    let b = right;
+    while (b !== 0n) {
+        [a, b] = [b, a % b];
+    }
+    return a;
+}
+function isPowerOfTwo(value) {
+    return value > 0n && (value & (value - 1n)) === 0n;
+}