eslint-plugin-sonarjs 4.0.2 → 4.1.0

package/cjs/helpers/dependency-manifests/dependencies.js

@@ -0,0 +1,255 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.moduleTypeCache = exports.dependenciesCache = void 0;
+exports.getDependencies = getDependencies;
+exports.getModuleType = getModuleType;
+exports.setCurrentFileInlineDependencies = setCurrentFileInlineDependencies;
+exports.withCurrentFileInlineDependencies = withCurrentFileInlineDependencies;
+exports.getDependenciesSanitizePaths = getDependenciesSanitizePaths;
+exports.getReactVersion = getReactVersion;
+exports.parseReactVersion = parseReactVersion;
+exports.getTypeScriptSignalsFromPackageJsonFiles = getTypeScriptSignalsFromPackageJsonFiles;
+exports.getNodeVersionSignal = getNodeVersionSignal;
+exports.getTypeScriptVersionSignal = getTypeScriptVersionSignal;
+const cache_js_1 = require("../cache.js");
+const node_fs_1 = __importDefault(require("node:fs"));
+const posix_1 = require("node:path/posix");
+const semver_1 = require("semver");
+const files_js_1 = require("../files.js");
+const closest_js_1 = require("./closest.js");
+const all_in_parent_dirs_js_1 = require("./all-in-parent-dirs.js");
+const types_js_1 = require("./resolvers/types.js");
+const parsed_dependency_files_js_1 = require("./parsed-dependency-files.js");
+const MODULE_TYPE_BY_EXTENSION = {
+    '.mjs': 'module',
+    '.mts': 'module',
+    '.cjs': 'commonjs',
+    '.cts': 'commonjs',
+};
+/**
+ * Cache for the available dependencies by dirname. Exported for tests
+ */
+exports.dependenciesCache = new cache_js_1.ComputedCache((dir, topDir) => {
+    const closestDependencyManifestDir = (0, closest_js_1.getClosestDependencyManifestDir)(dir, topDir);
+    const result = new Map();
+    if (!closestDependencyManifestDir) {
+        return result;
+    }
+    for (const { dependencies } of (0, all_in_parent_dirs_js_1.getDependencyManifests)(closestDependencyManifestDir, topDir, node_fs_1.default)) {
+        for (const [name, version] of dependencies) {
+            if (!result.has(name)) {
+                result.set(name, version);
+            }
+        }
+    }
+    return result;
+});
+/**
+ * Cache for module type signal by dirname. Exported for tests.
+ */
+exports.moduleTypeCache = new cache_js_1.ComputedCache((dir, topDir) => {
+    const closestDependencyManifestDirName = (0, closest_js_1.getClosestDependencyManifestDir)(dir, topDir);
+    if (!closestDependencyManifestDirName) {
+        return undefined;
+    }
+    const [firstManifest] = (0, all_in_parent_dirs_js_1.getDependencyManifests)(closestDependencyManifestDirName, topDir, node_fs_1.default);
+    return firstManifest?.moduleType;
+});
+/**
+ * Retrieve the dependencies of all the dependency manifest files available for the given file.
+ *
+ * @param dir dirname of the context.filename
+ * @param topDir working dir, will search up to that root
+ * @returns Map of dependency names to their version strings
+ */
+function getDependencies(dir, topDir) {
+    const closestDependencyManifestDir = (0, closest_js_1.getClosestDependencyManifestDir)(dir, topDir);
+    if (closestDependencyManifestDir) {
+        return exports.dependenciesCache.get(closestDependencyManifestDir, topDir);
+    }
+    return new Map();
+}
+/**
+ * Retrieve the module type signal for a file.
+ *
+ * Extension-specific module kinds (.mjs/.mts and .cjs/.cts) are explicit and
+ * take precedence. Otherwise, package.json#type from the closest manifest only
+ * is used. If that closest manifest exists but omits "type", default to CommonJS.
+ */
+function getModuleType(filePath, topDir) {
+    const extensionSignal = MODULE_TYPE_BY_EXTENSION[(0, posix_1.extname)(filePath).toLowerCase()];
+    if (extensionSignal) {
+        return extensionSignal;
+    }
+    return exports.moduleTypeCache.get((0, files_js_1.dirnamePath)(filePath), topDir);
+}
+/**
+ * Inline npm: imports parsed from the source file currently being linted (Deno-style).
+ * Set by the linter before each file is verified, cleared afterwards via clearFileCaches().
+ * Allows dependency-helper consumers (getReactVersion, getDependenciesSanitizePaths)
+ * to see the same dependency picture as rule-activation filtering.
+ */
+let currentFileInlineDependencies = null;
+function setCurrentFileInlineDependencies(deps) {
+    currentFileInlineDependencies = deps;
+}
+/**
+ * Merges inline npm: imports with manifest dependencies, giving precedence to inline imports.
+ */
+function withCurrentFileInlineDependencies(manifest) {
+    if (!currentFileInlineDependencies || currentFileInlineDependencies.size === 0) {
+        return manifest;
+    }
+    const merged = new Map(manifest);
+    for (const [name, inlineVersion] of currentFileInlineDependencies) {
+        // Inline npm: imports are the version actually loaded at runtime for this file,
+        // so they take precedence over the project-wide manifest version.
+        if (merged.has(name)) {
+            const manifestVersion = merged.get(name);
+            if (manifestVersion !== inlineVersion) {
+                console.debug(`Dependency "${typeof name === 'string' ? name : name.pattern}" has a version conflict between the manifest ` +
+                    `(${manifestVersion ?? '<unspecified>'}) and an inline npm: import ` +
+                    `(${inlineVersion ?? '<unspecified>'}). Using the inline version.`);
+            }
+        }
+        merged.set(name, inlineVersion);
+    }
+    return merged;
+}
+function getDependenciesSanitizePaths(context) {
+    return withCurrentFileInlineDependencies(getDependencies((0, files_js_1.dirnamePath)((0, files_js_1.normalizeToAbsolutePath)(context.filename)), (0, files_js_1.normalizeToAbsolutePath)(context.cwd)));
+}
+/**
+ * Gets the React version from the closest package.json.
+ *
+ * @param context ESLint rule context
+ * @returns React version string (coerced from range) or null if not found
+ */
+function getReactVersion(context) {
+    const dir = (0, files_js_1.dirnamePath)((0, files_js_1.normalizeToAbsolutePath)(context.filename));
+    const dependencies = withCurrentFileInlineDependencies(getDependencies(dir, (0, files_js_1.normalizeToAbsolutePath)(context.cwd)));
+    const reactVersion = dependencies.get('react');
+    // Deno npm: imports reflect the actual runtime version and are intentionally included here, unlike the TypeScript/Node.js version signals
+    if (!reactVersion) {
+        return null;
+    }
+    return parseReactVersion(reactVersion);
+}
+/**
+ * Parses a React version string and returns a valid semver version.
+ * Exported for testing purposes.
+ *
+ * @param reactVersion Version string from package.json (e.g., "^18.0.0", "19.0", "catalog:frontend")
+ * @returns Valid semver version string or null if parsing fails
+ */
+function parseReactVersion(reactVersion) {
+    try {
+        // Coerce version ranges (e.g., "^18.0.0") to valid semver versions
+        return (0, semver_1.minVersion)(reactVersion)?.version ?? null;
+    }
+    catch {
+        // Handle non-semver strings like pnpm catalog references (e.g., "catalog:frontend")
+        return null;
+    }
+}
+function getAllDependencySignals(packageJson) {
+    return {
+        ...packageJson.dependencies,
+        ...packageJson.devDependencies,
+        ...packageJson.peerDependencies,
+        ...packageJson.optionalDependencies,
+    };
+}
+function getDependencyVersionSignal(packageJson, dependencyName) {
+    const dependencyVersion = getAllDependencySignals(packageJson)[dependencyName];
+    return typeof dependencyVersion === 'string' ? dependencyVersion : null;
+}
+function getVersionSignalFromManifests(dir, topDir, dependencyName, fallbackSignal) {
+    // Walk up nearest-first. At each node manifest, prefer the primary signal
+    // (e.g. @types/node — catalog/workspace-resolved by the npm resolver) over the
+    // fallback (engines.node, read from the same manifest's PackageJson). The
+    // first valid primary signal wins; otherwise the first valid fallback wins; if
+    // neither is valid, continue walking parents. This lets a parent package's
+    // engines.node be picked up when the nested package declares neither signal,
+    // or only unusable fallbacks like "*" / "latest".
+    // Deno manifests are skipped — @types/node and engines.node are npm concepts.
+    const lookupKey = dependencyName.startsWith(types_js_1.DEFINITELY_TYPED)
+        ? dependencyName.substring(types_js_1.DEFINITELY_TYPED.length)
+        : dependencyName;
+    for (const manifest of (0, all_in_parent_dirs_js_1.getDependencyManifests)((0, files_js_1.normalizeToAbsolutePath)(dir), (0, files_js_1.normalizeToAbsolutePath)(topDir), node_fs_1.default)) {
+        if (manifest.type !== 'package-json') {
+            continue;
+        }
+        const version = manifest.dependencies.get(lookupKey) ?? null;
+        if (isValidDependencySignal(version)) {
+            return version;
+        }
+        if (fallbackSignal) {
+            const fb = fallbackSignal(manifest.manifest);
+            if (isValidDependencySignal(fb)) {
+                return fb;
+            }
+        }
+    }
+    return null;
+}
+function isValidDependencySignal(versionSignal) {
+    return versionSignal !== null && versionSignal !== 'latest' && versionSignal !== '*';
+}
+function hasTypeScriptNativePreviewSignal(packageJson) {
+    return isValidDependencySignal(getDependencyVersionSignal(packageJson, '@typescript/native-preview'));
+}
+function getTypeScriptVersionSignalsFromPackageJson(packageJson) {
+    const result = [];
+    const nativePreviewVersion = getDependencyVersionSignal(packageJson, '@typescript/native-preview');
+    if (isValidDependencySignal(nativePreviewVersion)) {
+        result.push(nativePreviewVersion);
+    }
+    const typeScriptVersion = getDependencyVersionSignal(packageJson, 'typescript');
+    if (isValidDependencySignal(typeScriptVersion)) {
+        result.push(typeScriptVersion);
+    }
+    return result;
+}
+function getTypeScriptSignalsFromPackageJsonFiles(packageJsonFiles) {
+    const typeScriptVersionSignals = [];
+    let hasTypeScriptNativePreview = false;
+    for (const packageJsonFile of packageJsonFiles) {
+        const packageJson = (0, parsed_dependency_files_js_1.parsePackageJsonContent)(packageJsonFile.fileContent);
+        if (packageJson === undefined) {
+            continue;
+        }
+        typeScriptVersionSignals.push(...getTypeScriptVersionSignalsFromPackageJson(packageJson));
+        hasTypeScriptNativePreview =
+            hasTypeScriptNativePreview || hasTypeScriptNativePreviewSignal(packageJson);
+    }
+    return { typeScriptVersionSignals, hasTypeScriptNativePreview };
+}
+/**
+ * Gets a Node.js version signal by walking up from `dir` toward `topDir`,
+ * picking the closest package.json with @types/node (preferred) or engines.node.
+ *
+ * @param dir directory to start the upward search from (e.g. tsconfig dir, file dir)
+ * @param topDir analysis base directory; walk stops here. Defaults to `dir` to
+ *   preserve the legacy "manifest at exactly this dir" semantics for callers
+ *   that don't yet provide a separate analysis root.
+ * @returns raw version string from @types/node or engines.node, or null if not found
+ */
+function getNodeVersionSignal(dir, topDir = dir) {
+    return getVersionSignalFromManifests(dir, topDir, '@types/node', packageJson => {
+        const enginesNode = packageJson.engines?.['node'];
+        return typeof enginesNode === 'string' ? enginesNode : null;
+    });
+}
+/**
+ * Gets a TypeScript version signal from the closest package.json walking up
+ * from `dir` to `topDir`. Defaults `topDir = dir` for backward compatibility.
+ *
+ * @returns raw version string from typescript dependency, or null if not found
+ */
+function getTypeScriptVersionSignal(dir, topDir = dir) {
+    return getVersionSignalFromManifests(dir, topDir, 'typescript');
+}

package/cjs/helpers/dependency-manifests/index.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PRELOADABLE_DEPENDENCY_MANIFESTS = exports.DEPENDENCY_MANIFESTS = exports.PNPM_WORKSPACE_YAML = exports.DENO_JSONC = exports.DENO_JSON = exports.PACKAGE_JSON = void 0;
+exports.isPreloadableDependencyManifestPath = isPreloadableDependencyManifestPath;
+exports.fillManifestCaches = fillManifestCaches;
+exports.clearDependenciesCache = clearDependenciesCache;
+exports.getPreloadableDependencyManifestName = getPreloadableDependencyManifestName;
+const find_minimatch_js_1 = require("../find-up/find-minimatch.js");
+const dependencies_js_1 = require("./dependencies.js");
+const closest_js_1 = require("../find-up/closest.js");
+const all_in_parent_dirs_js_1 = require("../find-up/all-in-parent-dirs.js");
+const posix_1 = require("node:path/posix");
+const parsed_dependency_files_js_1 = require("./parsed-dependency-files.js");
+exports.PACKAGE_JSON = 'package.json';
+exports.DENO_JSON = 'deno.json';
+exports.DENO_JSONC = 'deno.jsonc';
+exports.PNPM_WORKSPACE_YAML = 'pnpm-workspace.yaml';
+exports.DEPENDENCY_MANIFESTS = [exports.DENO_JSON, exports.DENO_JSONC, exports.PACKAGE_JSON];
+exports.PRELOADABLE_DEPENDENCY_MANIFESTS = [
+    ...exports.DEPENDENCY_MANIFESTS,
+    exports.PNPM_WORKSPACE_YAML,
+];
+function isPreloadableDependencyManifestName(fileName) {
+    return exports.PRELOADABLE_DEPENDENCY_MANIFESTS.includes(fileName);
+}
+function isPreloadableDependencyManifestPath(path) {
+    const normalizedBasename = (0, posix_1.basename)(path).toLowerCase();
+    return isPreloadableDependencyManifestName(normalizedBasename);
+}
+/**
+ * Preloads manifest lookup caches so later rules can resolve manifests
+ * without re-walking the file system.
+ */
+function fillManifestCaches(manifestName, manifests, dirnameToParent, topDir) {
+    const closestCache = closest_js_1.closestPatternCache.get(manifestName).get(topDir);
+    const manifestsInParentsCache = manifestName === exports.PNPM_WORKSPACE_YAML
+        ? undefined
+        : all_in_parent_dirs_js_1.patternInParentsCache.get(manifestName).get(topDir);
+    const sortedDirs = Array.from(dirnameToParent.entries()).sort(([leftDir], [rightDir]) => leftDir.split('/').length - rightDir.split('/').length || leftDir.localeCompare(rightDir));
+    for (const [dir, parent] of sortedDirs) {
+        const currentManifest = manifests.get(dir);
+        const inheritedClosestManifest = parent ? closestCache.get(parent) : undefined;
+        closestCache.set(dir, currentManifest ?? inheritedClosestManifest);
+        if (!manifestsInParentsCache) {
+            continue;
+        }
+        const manifestsInParents = parent ? [...manifestsInParentsCache.get(parent)] : [];
+        if (currentManifest) {
+            manifestsInParents.unshift(currentManifest);
+        }
+        manifestsInParentsCache.set(dir, manifestsInParents);
+    }
+}
+/**
+ * In the case of SonarIDE, when a dependency manifest file changes, the cache can become obsolete.
+ */
+function clearDependenciesCache() {
+    dependencies_js_1.dependenciesCache.clear();
+    dependencies_js_1.moduleTypeCache.clear();
+    (0, parsed_dependency_files_js_1.clearParsedDependencyFileCache)();
+    for (const manifestName of exports.PRELOADABLE_DEPENDENCY_MANIFESTS) {
+        closest_js_1.closestPatternCache.get(manifestName).clear();
+        if (manifestName !== exports.PNPM_WORKSPACE_YAML) {
+            all_in_parent_dirs_js_1.patternInParentsCache.get(manifestName).clear();
+        }
+    }
+    find_minimatch_js_1.MinimatchCache.clear();
+}
+/**
+ * Returns the preloadable dependency manifest filename if the path points to one.
+ */
+function getPreloadableDependencyManifestName(path) {
+    const normalizedBasename = (0, posix_1.basename)(path).toLowerCase();
+    if (isPreloadableDependencyManifestName(normalizedBasename)) {
+        return normalizedBasename;
+    }
+    return undefined;
+}

package/cjs/helpers/dependency-manifests/parse.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addDependencies = addDependencies;
+exports.addDependenciesArray = addDependenciesArray;
+exports.addDependency = addDependency;
+/*
+ * 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 minimatch_1 = require("minimatch");
+const types_js_1 = require("./resolvers/types.js");
+function addDependencies(result, dependencies, isGlob = false) {
+    for (const name of Object.keys(dependencies).filter(name => {
+        // Add this filter, as the PackageJson.Dependency can be any arbitrary JSON contrary to the claimed Record<String, String> typing.
+        const value = dependencies[name];
+        return typeof value === 'string' || value === undefined;
+    })) {
+        addDependency(result, { dependency: name, isGlob, version: dependencies[name] });
+    }
+}
+function addDependenciesArray(result, dependencies, isGlob = true) {
+    for (const name of dependencies) {
+        addDependency(result, { dependency: name, isGlob });
+    }
+}
+function addDependency(result, { dependency, isGlob, version, alias }) {
+    if (isGlob) {
+        result.set(new minimatch_1.Minimatch(dependency, { nocase: true, matchBase: true }), version);
+    }
+    else {
+        result.set(dependency.startsWith(types_js_1.DEFINITELY_TYPED)
+            ? dependency.substring(types_js_1.DEFINITELY_TYPED.length)
+            : dependency, version);
+    }
+    if (alias) {
+        // Also add the alias as a dependency, so it can be resolved in rules, for instance S4328
+        result.set(alias, version);
+    }
+}

package/cjs/helpers/dependency-manifests/parsed-dependency-files.js

@@ -0,0 +1,80 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.clearParsedDependencyFileCache = clearParsedDependencyFileCache;
+exports.parsePackageJson = parsePackageJson;
+exports.parsePackageJsonContent = parsePackageJsonContent;
+exports.parsePnpmWorkspace = parsePnpmWorkspace;
+exports.parseDenoManifest = parseDenoManifest;
+const typescript_1 = __importDefault(require("typescript"));
+const yaml_1 = __importDefault(require("yaml"));
+const files_js_1 = require("../files.js");
+const parsedPackageJsonCache = new Map();
+const parsedPnpmWorkspaceCache = new Map();
+const parsedDenoManifestCache = new Map();
+function clearParsedDependencyFileCache() {
+    parsedPackageJsonCache.clear();
+    parsedPnpmWorkspaceCache.clear();
+    parsedDenoManifestCache.clear();
+}
+function getOrSetParsedDependencyFile(cache, file, parse) {
+    const cacheKey = (0, files_js_1.normalizeToAbsolutePath)(file.filePath);
+    if (cache.has(cacheKey)) {
+        return cache.get(cacheKey);
+    }
+    const parsed = parse(file);
+    cache.set(cacheKey, parsed);
+    return parsed;
+}
+function parsePackageJson(file) {
+    return getOrSetParsedDependencyFile(parsedPackageJsonCache, file, file => parsePackageJsonContent(file.fileContent, file.filePath));
+}
+function parsePackageJsonContent(content, filePath) {
+    try {
+        return JSON.parse((0, files_js_1.stripBOM)(content));
+    }
+    catch (error) {
+        if (filePath) {
+            console.debug(`Error parsing package.json ${filePath}: ${error}`);
+        }
+        return undefined;
+    }
+}
+function parsePnpmWorkspace(file) {
+    return getOrSetParsedDependencyFile(parsedPnpmWorkspaceCache, file, parsePnpmWorkspaceContent);
+}
+function parsePnpmWorkspaceContent(file) {
+    try {
+        const parsedPnpm = yaml_1.default.parse(file.fileContent);
+        if (parsedPnpm &&
+            ('catalog' in parsedPnpm || 'catalogs' in parsedPnpm || 'packages' in parsedPnpm)) {
+            return parsedPnpm;
+        }
+        return undefined;
+    }
+    catch (error) {
+        console.debug(`Error parsing pnpm workspace ${file.filePath}: ${error}`);
+        return undefined;
+    }
+}
+function parseDenoManifest(file) {
+    return getOrSetParsedDependencyFile(parsedDenoManifestCache, file, parseDenoManifestContent);
+}
+function parseDenoManifestContent(file) {
+    try {
+        // ts.parseConfigFileTextToJson handles JSON with comments and trailing commas
+        const parsed = typescript_1.default.parseConfigFileTextToJson(file.filePath, (0, files_js_1.stripBOM)(file.fileContent));
+        if (parsed.error) {
+            const message = typescript_1.default.flattenDiagnosticMessageText(parsed.error.messageText, '\n');
+            console.debug(`Error parsing deno manifest ${file.filePath}: ${message}`);
+            return;
+        }
+        return parsed.config;
+    }
+    catch (error) {
+        console.debug(`Error parsing deno manifest ${file.filePath}: ${error}`);
+        return;
+    }
+}

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

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.denoManifestResolver = void 0;
+exports.parseInlineNPMImport = parseInlineNPMImport;
+const index_js_1 = require("../index.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.denoManifestResolver = {
+    resolve(dir, topDir, fileSystem) {
+        // if both `deno.json` and `deno.jsonc` are present, prefer `deno.json` and ignore `deno.jsonc`
+        const denoJson = (0, helpers_js_1.getManifestFileInDir)(index_js_1.DENO_JSON, dir, topDir, fileSystem);
+        const denoJsonc = (0, helpers_js_1.getManifestFileInDir)(index_js_1.DENO_JSONC, dir, topDir, fileSystem);
+        const denoModuleType = 'module';
+        const effectiveDenoJson = denoJson ?? denoJsonc;
+        if (effectiveDenoJson) {
+            const manifest = (0, parsed_dependency_files_js_1.parseDenoManifest)(effectiveDenoJson) ?? {};
+            return [
+                {
+                    type: 'deno',
+                    manifest,
+                    dependencies: buildDependencies(manifest),
+                    moduleType: denoModuleType,
+                },
+            ];
+        }
+        return [];
+    },
+};
+function buildDependencies(manifest) {
+    const dependencies = new Map();
+    if (manifest.imports && typeof manifest.imports === 'object') {
+        for (const [alias, target] of Object.entries(manifest.imports)) {
+            if (typeof target !== 'string') {
+                continue;
+            }
+            const parsedSpecifier = parseInlineNPMImport(target);
+            if (parsedSpecifier) {
+                (0, parse_js_1.addDependency)(dependencies, {
+                    dependency: parsedSpecifier.packageName,
+                    isGlob: false,
+                    version: parsedSpecifier.version,
+                    alias,
+                });
+            }
+        }
+    }
+    if (Array.isArray(manifest.workspace)) {
+        (0, parse_js_1.addDependenciesArray)(dependencies, manifest.workspace);
+    }
+    else if (manifest.workspace?.members) {
+        (0, parse_js_1.addDependenciesArray)(dependencies, manifest.workspace.members);
+    }
+    return dependencies;
+}
+// Captures `npm:` payload as: package name (scoped or unscoped), optional version, optional ignored subpath.
+// Examples:
+// npm:cowsay@^1.6.0
+// npm:@scopename/mypackage@~11.1.0
+const DENO_NPM_IMPORT_PATTERN = /^(@[^/]*\/[^/@]*|[^/@]+)(?:@([^/]*))?(?:\/.*)?$/;
+/**
+ * Parses an import map URL Specifier matching Deno npm format:
+ * npm:<package>[@<version>][/<path>]
+ */
+function parseInlineNPMImport(value) {
+    // currently only handle npm: specifiers since rules are focused on NPM dependencies
+    if (!value.startsWith('npm:')) {
+        return undefined;
+    }
+    const match = DENO_NPM_IMPORT_PATTERN.exec(value.slice('npm:'.length));
+    if (!match) {
+        return undefined;
+    }
+    const [, packageName, version] = match;
+    return {
+        packageName,
+        version: version || undefined,
+    };
+}

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

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getManifestFileInDir = getManifestFileInDir;
+exports.getParentDirPath = getParentDirPath;
+/*
+ * 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 files_js_1 = require("../../files.js");
+const closest_js_1 = require("../../find-up/closest.js");
+/**
+ * Returns the manifest file at exactly `dir` (not a parent directory), or `undefined` if absent.
+ */
+function getManifestFileInDir(manifestName, dir, topDir, fileSystem) {
+    const file = closest_js_1.closestPatternCache.get(manifestName, fileSystem).get(topDir).get(dir);
+    if (file && (0, files_js_1.dirnamePath)(file.filePath) === dir) {
+        return file;
+    }
+    return undefined;
+}
+/**
+ * Get the parent directory of the given path.
+ * @param path Path to get the parent directory of.
+ * @returns The parent directory or `null` if it is the root directory.
+ */
+function getParentDirPath(path) {
+    const parentDir = (0, files_js_1.dirnamePath)(path);
+    return parentDir === path ? null : parentDir;
+}