@nx/oxlint 23.2.0-rc.0 → 23.2.0-rc.2

package/dist/src/plugins/plugin.js

@@ -1,4 +1,4 @@
-import { buildPackageJsonPatterns, buildPackageJsonWorkspacesMatcher, calculateHashesForCreateNodes, combineGlobPatterns, globWithWorkspaceContext, hashObject, PluginCache, TargetProjectLocator, workspaceDataDirectory, } from '@nx/devkit/internal';
+import { buildPackageJsonPatterns, buildPackageJsonWorkspacesMatcher, calculateHashesForCreateNodes, combineGlobPatterns, globWithWorkspaceContext, hashObject, PluginCache, TargetProjectLocator, workspaceDataDirectory, quoteShellArg, } from '@nx/devkit/internal';
 import { createNodesFromFiles, DependencyType, detectPackageManager, getPackageManagerCommand, readJsonFile, validateDependency, } from '@nx/devkit';
 import { getLockFileName, getRootTsConfigFileName } from '@nx/js';
 import { walkTsconfigExtendsChain, } from '@nx/js/internal';
@@ -27,6 +27,8 @@ const LINTABLE_EXTENSIONS = [
     'astro',
 ];
 const LINTABLE_FILES_GLOB = `**/*.{${LINTABLE_EXTENSIONS.join(',')}}`;
+// Oxlint honours both, so both decide which files it lints.
+const IGNORE_FILENAMES = ['.eslintignore', '.gitignore'];
 // The one rule that looks across projects; every other rule sees one file.
 const BOUNDARIES_PLUGIN_SPECIFIER = '@nx/oxlint/boundaries-plugin';
 const PROJECT_CONFIG_FILENAMES = ['project.json', 'package.json'];
@@ -34,7 +36,7 @@ const OXLINT_CONFIG_GLOB = combineGlobPatterns([
     ...OXLINT_CONFIG_FILENAMES.map((f) => `**/${f}`),
     ...PROJECT_CONFIG_FILENAMES.map((f) => `**/${f}`),
 ]);
-const internalCreateNodes = async (configFilePath, options, context, projectRootsByOxlintRoots, getLintableFilesPerProjectRoot, configChainsByConfig, jsPluginSpecifiersByConfig, tsconfigChainsByProjectRoot, projectsCache, hashByRoot, pmc, rootConfig) => {
+const internalCreateNodes = async (configFilePath, options, context, projectRootsByOxlintRoots, nestedRootsByParent, getLintableFilesPerProjectRoot, configChainsByConfig, jsPluginSpecifiersByConfig, tsconfigChainsByProjectRoot, projectsCache, hashByRoot, pmc, rootConfig) => {
     const configDir = dirname(configFilePath);
     // Collect each project root's contribution in parallel, but write them into
     // `projects` afterwards in input order so insertion order (and therefore
@@ -55,7 +57,7 @@ const internalCreateNodes = async (configFilePath, options, context, projectRoot
             projectsCache.set(hash, {});
             return null;
         }
-        const project = getProjectUsingOxlintConfig(configFilePath, projectRoot, options, context, pmc, configChainsByConfig, jsPluginSpecifiersByConfig, tsconfigChainsByProjectRoot.get(projectRoot) ?? [], rootConfig);
+        const project = getProjectUsingOxlintConfig(configFilePath, projectRoot, nestedRootsByParent, options, context, pmc, configChainsByConfig, jsPluginSpecifiersByConfig, tsconfigChainsByProjectRoot.get(projectRoot) ?? [], rootConfig);
         if (project) {
             const entry = { [projectRoot]: project };
             projectsCache.set(hash, entry);
@@ -80,6 +82,7 @@ export const createNodes = [
         const cachePath = join(workspaceDataDirectory, `oxlint-${optionsHash}.hash`);
         const targetsCache = new PluginCache(cachePath);
         const { oxlintConfigFiles, projectRoots, projectRootsByOxlintRoots } = splitConfigFiles(configFiles, context.workspaceRoot);
+        const nestedRootsByParent = nestedRootsByParentRoot(projectRoots);
         // The glob also matches `**/package.json`, so this callback runs in every
         // workspace, Oxlint or not. Bail before the chain walks and the hashing.
         if (oxlintConfigFiles.length === 0) {
@@ -118,7 +121,7 @@ export const createNodes = [
                     ...allConfigs.flatMap((config) => localJsPluginFiles(config, jsPluginSpecifiersByConfig.get(config) ?? [])),
                     // Change which files Oxlint considers lintable, and therefore
                     // whether a target is inferred at all.
-                    ...ancestorEslintignorePaths(root),
+                    ...ancestorIgnorePaths(root),
                     lockFilePattern,
                     ...(tsconfigChainsByProjectRoot.get(root) ?? []),
                 ]),
@@ -126,7 +129,7 @@ export const createNodes = [
         }));
         const hashByRoot = new Map(projectRoots.map((r, i) => [r, hashes[i]]));
         try {
-            return await createNodesFromFiles((configFile, fileOptions, fileContext) => internalCreateNodes(configFile, fileOptions, fileContext, projectRootsByOxlintRoots, getLintableFilesPerProjectRoot, configChainsByConfig, jsPluginSpecifiersByConfig, tsconfigChainsByProjectRoot, targetsCache, hashByRoot, pmc, rootConfig), oxlintConfigFiles, options, context);
+            return await createNodesFromFiles((configFile, fileOptions, fileContext) => internalCreateNodes(configFile, fileOptions, fileContext, projectRootsByOxlintRoots, nestedRootsByParent, getLintableFilesPerProjectRoot, configChainsByConfig, jsPluginSpecifiersByConfig, tsconfigChainsByProjectRoot, targetsCache, hashByRoot, pmc, rootConfig), oxlintConfigFiles, options, context);
         }
         finally {
             targetsCache.writeToDisk();
@@ -518,16 +521,18 @@ async function collectLintableFilesByProjectRoot(projectRoots, context) {
     return lintableFilesPerProjectRoot;
 }
 /**
- * `.eslintignore` candidates in every ancestor directory of the project root,
+ * Ignore-file candidates in every ancestor directory of the project root,
  * workspace root included. The project's own directory is excluded — files
- * there are covered by the `default` input — except at the workspace root,
- * which is its own ancestor and so keeps its `.eslintignore`.
+ * there are covered by the in-project ignore-file input — except at the
+ * workspace root, which is its own ancestor and so keeps its ignore files.
  */
-function ancestorEslintignorePaths(projectRoot) {
+function ancestorIgnorePaths(projectRoot) {
     const result = [];
     let dir = projectRoot === '.' ? '.' : dirname(projectRoot);
     while (true) {
-        result.push(dir === '.' ? '.eslintignore' : `${dir}/.eslintignore`);
+        for (const filename of IGNORE_FILENAMES) {
+            result.push(dir === '.' ? filename : `${dir}/${filename}`);
+        }
         if (dir === '.') {
             break;
         }
@@ -535,7 +540,69 @@ function ancestorEslintignorePaths(projectRoot) {
     }
     return result;
 }
-// Only the keys are read, so the value type is left open for both callers.
+/**
+ * Escape the gitignore metacharacters in a path so `--ignore-pattern` matches it
+ * literally. The value crosses two languages and `quoteShellArg` only covers the
+ * shell: to Oxlint's matcher `\`, `[`, `]`, `*` and `?` are pattern syntax, and a
+ * trailing space is stripped unless escaped — so `/a[b]` excludes `ab` while
+ * leaving `a[b]` walked, which is both a miss and a silent over-exclusion.
+ */
+function escapeIgnorePattern(pattern) {
+    return pattern
+        .replace(/([\\[\]*?])/g, '\\$1')
+        .replace(/ +$/, (spaces) => spaces.replace(/ /g, '\\ '));
+}
+/**
+ * Direct child project roots for each project root, keyed by the parent. A root
+ * belongs to its NEAREST enclosing root, so a grandchild lands under the child
+ * rather than the grandparent — which is what keeps an outer project from
+ * emitting an exclusion that a shallower one already covers.
+ *
+ * Built once per run: resolving each root's parent by walking up is linear in
+ * the workspace, where asking every project which roots sit below it is not.
+ */
+function nestedRootsByParentRoot(projectRoots) {
+    // getRootForDirectory reads only the keys.
+    const roots = new Map(projectRoots.map((root) => [root, true]));
+    const byParent = new Map();
+    for (const root of projectRoots) {
+        const parent = getRootForDirectory(dirname(root), roots);
+        // A workspace-root project is its own ancestor, so it must not claim itself.
+        if (parent === null || parent === root) {
+            continue;
+        }
+        const claimed = byParent.get(parent);
+        if (claimed) {
+            claimed.push(root);
+        }
+        else {
+            byParent.set(parent, [root]);
+        }
+    }
+    for (const claimed of byParent.values()) {
+        claimed.sort();
+    }
+    return byParent;
+}
+/**
+ * The project roots nested directly below `projectRoot`, relative to it and
+ * limited to `lintDir` when the lint walk starts there. An excluded root either
+ * has its own inferred target or owns nothing lintable, so pruning it drops no
+ * lint coverage.
+ *
+ * Callers must emit each one anchored (`/dir`) and never as `dir/**`. A gitignore
+ * pattern is anchored only when it contains a slash, so a bare single-segment
+ * root would also match a same-named directory the outer project owns; and
+ * `dir/**` matches only entries inside `dir`, leaving Oxlint free to descend and
+ * read that directory's ignore files.
+ */
+function nestedProjectRoots(projectRoot, nestedRootsByParent, lintDir) {
+    const prefix = projectRoot === '.' ? '' : `${projectRoot}/`;
+    return (nestedRootsByParent.get(projectRoot) ?? [])
+        .map((root) => root.slice(prefix.length))
+        .filter((rel) => !lintDir || rel === lintDir || rel.startsWith(`${lintDir}/`));
+}
+// Only the keys are read, so the value type is left open for all callers.
 function getRootForDirectory(directory, roots) {
     let currentPath = normalize(directory);
     while (currentPath !== dirname(currentPath)) {
@@ -546,7 +613,7 @@ function getRootForDirectory(directory, roots) {
     }
     return roots.has(currentPath) ? currentPath : null;
 }
-function getProjectUsingOxlintConfig(configFilePath, projectRoot, options, context, pmc, configChainsByConfig, jsPluginSpecifiersByConfig, tsconfigChainOutsideProjectRoot, rootConfig) {
+function getProjectUsingOxlintConfig(configFilePath, projectRoot, nestedRootsByParent, options, context, pmc, configChainsByConfig, jsPluginSpecifiersByConfig, tsconfigChainOutsideProjectRoot, rootConfig) {
     let standaloneSrcPath;
     if (projectRoot === '.' &&
         existsSync(join(context.workspaceRoot, projectRoot, 'package.json'))) {
@@ -573,11 +640,17 @@ function getProjectUsingOxlintConfig(configFilePath, projectRoot, options, conte
     ];
     const isRootProject = projectRoot === '.';
     const lintPath = isRootProject && standaloneSrcPath ? `./${standaloneSrcPath}` : '.';
+    const nestedIgnoreArgs = nestedProjectRoots(projectRoot, nestedRootsByParent, isRootProject && standaloneSrcPath ? standaloneSrcPath : '')
+        // `quoteShellArg` documents that it cannot keep `%` literal through cmd.exe,
+        // so on Windows such a root is left unexcluded rather than excluded wrongly:
+        // it gets linted twice, which is what happened before this exclusion existed.
+        .filter((relativeRoot) => process.platform !== 'win32' || !relativeRoot.includes('%'))
+        .map((relativeRoot) => `--ignore-pattern ${quoteShellArg(escapeIgnorePattern(`/${relativeRoot}`))}`);
     const jsPluginFiles = new Set(configInputs.flatMap((config) => localJsPluginFiles(config, jsPluginSpecifiersByConfig.get(config) ?? [])));
     const lintableFiles = `{projectRoot}/${LINTABLE_FILES_GLOB}`;
     const usesBoundariesBridge = configInputs.some((config) => (jsPluginSpecifiersByConfig.get(config) ?? []).includes(BOUNDARIES_PLUGIN_SPECIFIER));
     const targetConfig = {
-        command: `oxlint ${lintPath}`,
+        command: `oxlint ${[lintPath, ...nestedIgnoreArgs].join(' ')}`,
         options: { cwd: projectRoot },
         cache: true,
         inputs: [
@@ -596,13 +669,13 @@ function getProjectUsingOxlintConfig(configFilePath, projectRoot, options, conte
                 : []),
             // Configs, ignore files and tsconfigs inside the project.
             {
-                fileset: `{projectRoot}/**/{${[...OXLINT_CONFIG_FILENAMES, '.eslintignore', 'tsconfig*.json'].join(',')}}`,
+                fileset: `{projectRoot}/**/{${[...OXLINT_CONFIG_FILENAMES, ...IGNORE_FILENAMES, 'tsconfig*.json'].join(',')}}`,
             },
             ...configInputs.map((config) => `{workspaceRoot}/${config}`),
             ...[...jsPluginFiles].map((file) => `{workspaceRoot}/${file}`),
-            // Oxlint layers .eslintignore files from every ancestor of a linted
-            // file. Declared even when absent, like the extends chain.
-            ...ancestorEslintignorePaths(projectRoot).map((file) => `{workspaceRoot}/${file}`),
+            // Oxlint layers ignore files from every ancestor of a linted file.
+            // Declared even when absent, like the extends chain.
+            ...ancestorIgnorePaths(projectRoot).map((file) => `{workspaceRoot}/${file}`),
             ...tsconfigChainOutsideProjectRoot.map((file) => `{workspaceRoot}/${file}`),
             { externalDependencies: ['oxlint'] },
         ],

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@nx/oxlint",
   "description": "Experimental. The Oxlint plugin for Nx contains generators and utilities used for linting JavaScript/TypeScript projects within an Nx workspace.",
-  "version": "23.2.0-rc.0",
+  "version": "23.2.0-rc.2",
   "type": "module",
   "files": [
     "dist",
@@ -69,9 +69,9 @@
   "generators": "./generators.json",
   "dependencies": {
     "tslib": "^2.3.0",
-    "@nx/devkit": "23.2.0-rc.0",
-    "@nx/eslint-plugin": "23.2.0-rc.0",
-    "@nx/js": "23.2.0-rc.0"
+    "@nx/devkit": "23.2.0-rc.2",
+    "@nx/eslint-plugin": "23.2.0-rc.2",
+    "@nx/js": "23.2.0-rc.2"
   },
   "peerDependencies": {
     "oxlint": "^1.43.0"
@@ -85,6 +85,6 @@
     "node": "^20.19.0 || >=22.12.0"
   },
   "devDependencies": {
-    "nx": "23.2.0-rc.0"
+    "nx": "23.2.0-rc.2"
   }
 }