@nx/devkit 23.2.0-beta.5 → 23.2.0-beta.6

package/dist/src/generators/format-files.d.ts

@@ -1,6 +1,8 @@
 import { Tree } from 'nx/src/devkit-exports';
 /**
- * Formats all the created or updated files using Prettier
+ * Formats the created or updated files using Prettier, skipping `node_modules`,
+ * `.git`, the nx and yarn caches, and anything the workspace's root
+ * `.gitignore` or `.prettierignore` covers
  * @param tree - the file system tree
  * @param options - options for the formatFiles function
  *

package/dist/src/generators/format-files.js

@@ -5,6 +5,7 @@ const tslib_1 = require("tslib");
 const devkit_exports_1 = require("nx/src/devkit-exports");
 const devkit_internals_1 = require("nx/src/devkit-internals");
 const path = tslib_1.__importStar(require("path"));
+const nx_ignore_internals_1 = require("../utils/nx-ignore-internals");
 // Prettier v3 (ESM) exposes its API as named exports; v2 (CJS) exposes it under
 // `.default` when loaded via `import()`. Return whichever carries the API, or
 // null if prettier isn't installed.
@@ -18,7 +19,9 @@ async function importPrettier() {
     }
 }
 /**
- * Formats all the created or updated files using Prettier
+ * Formats the created or updated files using Prettier, skipping `node_modules`,
+ * `.git`, the nx and yarn caches, and anything the workspace's root
+ * `.gitignore` or `.prettierignore` covers
  * @param tree - the file system tree
  * @param options - options for the formatFiles function
  *
@@ -56,7 +59,16 @@ async function formatFiles(tree, options = {}) {
     catch { }
     if (!prettier)
         return;
-    const files = new Set(tree.listChanges().filter((file) => file.type !== 'DELETE'));
+    // `getFileInfo` below looks like it filters ignored files but only covers its
+    // own built-in `node_modules` skip: with no `ignorePath` it never reads the
+    // workspace's ignore files, so `ignored` is false for everything else
+    // (measured).
+    //
+    // The optional call is the older-nx path - see `NOTHING_IGNORED`.
+    const { isIgnoredFile } = (0, devkit_internals_1.createPrettierIgnoreChecker)?.(tree) ?? nx_ignore_internals_1.NOTHING_IGNORED;
+    const files = new Set(tree
+        .listChanges()
+        .filter((file) => file.type !== 'DELETE' && !isIgnoredFile(file.path)));
     const changedPrettierInTree = getChangedPrettierConfigInTree(tree);
     await Promise.all(Array.from(files).map(async (file) => {
         try {

package/dist/src/generators/visit-not-ignored-files.d.ts

@@ -1,5 +1,12 @@
 import type { Tree } from 'nx/src/devkit-exports';
 /**
  * Utility to act on all files in a tree that are not ignored by git.
+ *
+ * Ignore files cascade, so a nested `.gitignore` covers the files under it and a
+ * nested negation overrides the root. They are read from the tree, not disk, so
+ * one a generator wrote in the same run counts.
+ *
+ * `node_modules`, `.git` and the nx and yarn caches are never visited, whatever
+ * the workspace's ignore files say.
  */
 export declare function visitNotIgnoredFiles(tree: Tree, dirPath: string, visitor: (path: string) => void): void;

package/dist/src/generators/visit-not-ignored-files.js

@@ -3,25 +3,50 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.visitNotIgnoredFiles = visitNotIgnoredFiles;
 const devkit_internals_1 = require("nx/src/devkit-internals");
 const path_1 = require("path");
+const nx_ignore_internals_1 = require("../utils/nx-ignore-internals");
 /**
  * Utility to act on all files in a tree that are not ignored by git.
+ *
+ * Ignore files cascade, so a nested `.gitignore` covers the files under it and a
+ * nested negation overrides the root. They are read from the tree, not disk, so
+ * one a generator wrote in the same run counts.
+ *
+ * `node_modules`, `.git` and the nx and yarn caches are never visited, whatever
+ * the workspace's ignore files say.
  */
 function visitNotIgnoredFiles(tree, dirPath = tree.root, visitor) {
-    const ig = (0, devkit_internals_1.getIgnoreObjectForTree)(tree);
-    dirPath = normalizePathRelativeToRoot(dirPath, tree.root);
-    if (dirPath !== '' && ig?.ignores(dirPath)) {
+    (0, nx_ignore_internals_1.assertNxSupportsIgnoreCheckers)();
+    // Built once for the whole traversal.
+    const isIgnored = (0, devkit_internals_1.createGitIgnoreChecker)(tree);
+    const start = normalizePathRelativeToRoot(dirPath, tree.root);
+    // The caller's own directory is the only one nothing has checked - every
+    // deeper one is checked before it is descended into.
+    if (start !== '' && isIgnored.isIgnoredDirectory(start)) {
         return;
     }
+    visitDirectory(tree, start, visitor, isIgnored);
+}
+/**
+ * Callers must have cleared `dirPath` already - both call sites do.
+ *
+ * Not descending into an ignored directory is what makes the answers match git,
+ * not just what makes them fast: git refuses to re-include a file inside an
+ * excluded directory, and `isIgnoredFile` alone does not implement that rule
+ * (see `isIgnoredByChain`). Flattening this into a per-file filter would start
+ * visiting files git ignores.
+ */
+function visitDirectory(tree, dirPath, visitor, isIgnored) {
     for (const child of tree.children(dirPath)) {
-        const fullPath = (0, path_1.join)(dirPath, child);
-        if (ig?.ignores(fullPath)) {
-            continue;
-        }
+        // Joined as POSIX rather than with `path.join`: tree paths are POSIX, and
+        // on Windows a backslash-separated path silently matches nothing.
+        const fullPath = dirPath ? `${dirPath}/${child}` : child;
         if (tree.isFile(fullPath)) {
-            visitor(fullPath);
+            if (!isIgnored.isIgnoredFile(fullPath)) {
+                visitor(fullPath);
+            }
         }
-        else {
-            visitNotIgnoredFiles(tree, fullPath, visitor);
+        else if (!isIgnored.isIgnoredDirectory(fullPath)) {
+            visitDirectory(tree, fullPath, visitor, isIgnored);
         }
     }
 }

package/dist/src/utils/invoke-nx-generator.js

@@ -141,9 +141,13 @@ class DevkitTreeFromAngularDevkitTree {
         return (0, path_1.relative)(this.root, (0, path_1.join)(this.root, path));
     }
     read(filePath, encoding) {
-        return encoding
-            ? this.tree.read(filePath).toString(encoding)
-            : this.tree.read(filePath);
+        // The schematics tree already returns null for a missing file, so honouring
+        // the `Tree` contract is a matter of not dereferencing it.
+        const content = this.tree.read(filePath);
+        if (content === null) {
+            return null;
+        }
+        return encoding ? content.toString(encoding) : content;
     }
     rename(from, to) {
         this.tree.rename(from, to);

package/dist/src/utils/nx-ignore-internals.d.ts

@@ -0,0 +1,23 @@
+import type { TreeIgnoreChecker } from 'nx/src/devkit-internals';
+/**
+ * `@nx/devkit`'s `nx` peer spans a major either side, so an older nx that
+ * predates the ignore checkers can legally be installed alongside it, and a
+ * missing CommonJS named export arrives as `undefined` rather than as a load
+ * error. The two callers want opposite things from that, so they get different
+ * helpers - see `NOTHING_IGNORED` for the other half.
+ *
+ * A tree walk cannot degrade: without a checker nothing would be ignored, and
+ * the walker would descend into `node_modules` and hand a migration every file
+ * in it to rewrite. That is worse than the older nx's own behaviour, which at
+ * least read the root `.gitignore`, so this fails instead - once, by name.
+ */
+export declare function assertNxSupportsIgnoreCheckers(): void;
+/**
+ * The degrade the other way, for formatting.
+ *
+ * Filtering nothing is what devkit did before the checkers existed - with no
+ * `ignorePath`, prettier's own `getFileInfo` never read the workspace's ignore
+ * files either (measured) - so an older nx gets the formatting behaviour it has
+ * always had rather than a generator that refuses to run.
+ */
+export declare const NOTHING_IGNORED: TreeIgnoreChecker;

package/dist/src/utils/nx-ignore-internals.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NOTHING_IGNORED = void 0;
+exports.assertNxSupportsIgnoreCheckers = assertNxSupportsIgnoreCheckers;
+const devkit_internals_1 = require("nx/src/devkit-internals");
+/**
+ * `@nx/devkit`'s `nx` peer spans a major either side, so an older nx that
+ * predates the ignore checkers can legally be installed alongside it, and a
+ * missing CommonJS named export arrives as `undefined` rather than as a load
+ * error. The two callers want opposite things from that, so they get different
+ * helpers - see `NOTHING_IGNORED` for the other half.
+ *
+ * A tree walk cannot degrade: without a checker nothing would be ignored, and
+ * the walker would descend into `node_modules` and hand a migration every file
+ * in it to rewrite. That is worse than the older nx's own behaviour, which at
+ * least read the root `.gitignore`, so this fails instead - once, by name.
+ */
+function assertNxSupportsIgnoreCheckers() {
+    if (devkit_internals_1.createGitIgnoreChecker) {
+        return;
+    }
+    throw new Error('The installed version of nx does not export the ignore checkers that @nx/devkit needs to decide which files a generator may touch. ' +
+        'This happens when nx and @nx/devkit are on different major versions. Run `nx migrate latest` to bring them into line.');
+}
+/**
+ * The degrade the other way, for formatting.
+ *
+ * Filtering nothing is what devkit did before the checkers existed - with no
+ * `ignorePath`, prettier's own `getFileInfo` never read the workspace's ignore
+ * files either (measured) - so an older nx gets the formatting behaviour it has
+ * always had rather than a generator that refuses to run.
+ */
+exports.NOTHING_IGNORED = {
+    isIgnoredFile: () => false,
+    isIgnoredDirectory: () => false,
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nx/devkit",
-  "version": "23.2.0-beta.5",
+  "version": "23.2.0-beta.6",
   "private": false,
   "type": "commonjs",
   "files": [
@@ -68,7 +68,7 @@
   },
   "devDependencies": {
     "jest": "30.3.0",
-    "nx": "23.2.0-beta.5"
+    "nx": "23.2.0-beta.6"
   },
   "peerDependencies": {
     "nx": ">= 22 <= 24 || ^23.0.0-0"