nx 23.2.0-beta.8 → 23.2.0-beta.9

package/dist/src/utils/formatters/prettier.d.ts

@@ -0,0 +1,26 @@
+import type { Tree } from '../../generators/tree';
+/**
+ * Config filenames prettier discovers. Exported because generator setup must
+ * agree with detection - a format missing from one side gets a second,
+ * redundant config written next to it.
+ * https://prettier.io/docs/configuration
+ */
+export declare const prettierConfigFiles: string[];
+export declare function isUsingPrettier(root: string): boolean;
+export declare function isUsingPrettierInTree(tree: Tree): boolean;
+/**
+ * Keeps only the files prettier can format. oxfmt needs no equivalent - it
+ * silently skips file types it does not handle.
+ */
+export declare function filterToPrettierSupportedFiles(files: string[]): Promise<string[]>;
+export declare function writeWithPrettier(patterns: string[], cwd?: string): void;
+export declare function checkWithPrettier(patterns: string[]): Promise<string[]>;
+export declare function getPrettierPath(): string;
+/**
+ * Quote a pattern for prettier's shell-based exec calls; oxfmt uses execFile
+ * and takes raw paths.
+ *
+ * Exported so `nx format` can size its chunks against the quoted length -
+ * patterns are chunked before they get here, and quoting grows each one.
+ */
+export declare function quoteForShell(pattern: string): string;

package/dist/src/utils/formatters/prettier.js

@@ -0,0 +1,201 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.prettierConfigFiles = void 0;
+exports.isUsingPrettier = isUsingPrettier;
+exports.isUsingPrettierInTree = isUsingPrettierInTree;
+exports.filterToPrettierSupportedFiles = filterToPrettierSupportedFiles;
+exports.writeWithPrettier = writeWithPrettier;
+exports.checkWithPrettier = checkWithPrettier;
+exports.getPrettierPath = getPrettierPath;
+exports.quoteForShell = quoteForShell;
+const node_child_process_1 = require("node:child_process");
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const semver_1 = require("semver");
+const json_1 = require("../../generators/utils/json");
+const fileutils_1 = require("../fileutils");
+const handle_import_1 = require("../handle-import");
+const package_json_1 = require("../package-json");
+const shared_1 = require("./shared");
+/**
+ * Config filenames prettier discovers. Exported because generator setup must
+ * agree with detection - a format missing from one side gets a second,
+ * redundant config written next to it.
+ * https://prettier.io/docs/configuration
+ */
+exports.prettierConfigFiles = [
+    '.prettierrc',
+    '.prettierrc.json',
+    '.prettierrc.yml',
+    '.prettierrc.yaml',
+    '.prettierrc.json5',
+    '.prettierrc.js',
+    'prettier.config.js',
+    '.prettierrc.ts',
+    'prettier.config.ts',
+    '.prettierrc.mjs',
+    'prettier.config.mjs',
+    '.prettierrc.mts',
+    'prettier.config.mts',
+    '.prettierrc.cjs',
+    'prettier.config.cjs',
+    '.prettierrc.cts',
+    'prettier.config.cts',
+    '.prettierrc.toml',
+];
+function isUsingPrettier(root) {
+    for (const file of exports.prettierConfigFiles) {
+        if ((0, node_fs_1.existsSync)((0, node_path_1.join)(root, file))) {
+            return true;
+        }
+    }
+    // Even if no file is present, it is possible the user is configuring prettier via their package.json
+    const packageJsonPath = (0, node_path_1.join)(root, 'package.json');
+    if ((0, node_fs_1.existsSync)(packageJsonPath)) {
+        const packageJson = (0, fileutils_1.readJsonFile)(packageJsonPath);
+        if (packageJson.prettier) {
+            return true;
+        }
+    }
+    return false;
+}
+function isUsingPrettierInTree(tree) {
+    for (const file of exports.prettierConfigFiles) {
+        if (tree.exists(file)) {
+            return true;
+        }
+    }
+    // Even if no file is present, it is possible the user is configuring prettier via their package.json
+    if (tree.exists('package.json')) {
+        const packageJson = (0, json_1.readJson)(tree, 'package.json');
+        if (packageJson.prettier) {
+            return true;
+        }
+    }
+    return false;
+}
+/**
+ * Keeps only the files prettier can format. oxfmt needs no equivalent - it
+ * silently skips file types it does not handle.
+ */
+async function filterToPrettierSupportedFiles(files) {
+    const prettier = await (0, handle_import_1.handleImport)('prettier');
+    const supportInfo = await prettier.getSupportInfo();
+    const supportedExtensions = new Set(supportInfo.languages
+        .flatMap((language) => language.extensions)
+        .filter((extension) => !!extension));
+    // Prettier matches ~30 files by *name* rather than extension (`.swcrc`,
+    // `Jakefile`). It publishes that list next to the extensions, so read it
+    // rather than hardcoding.
+    const supportedFilenames = new Set(supportInfo.languages.flatMap((language) => language.filenames ?? []));
+    return files.filter((file) => supportedExtensions.has((0, node_path_1.extname)(file)) ||
+        supportedFilenames.has((0, node_path_1.basename)(file)));
+}
+function writeWithPrettier(patterns, 
+// Defaults to the caller's cwd. `nx init` sets it so it can pass paths
+// relative to the repo root rather than absolute ones the user has to read.
+cwd) {
+    if (patterns.length === 0) {
+        // Prettier with no file arguments reads stdin, and `stdio: [0, 1, 2]` hands
+        // it nx's own - from a terminal it blocks forever with nothing on screen. At
+        // EOF it exits 0 under `--list-different` and 2 (which `execSync` throws on)
+        // without it, so which failure you get depends on `shouldUseListDifferent`.
+        return;
+    }
+    const prettierPath = getPrettierPath();
+    const listDifferentArg = shouldUseListDifferent() ? '--list-different ' : '';
+    // No `--parser json` special case for `.swcrc`: prettier's own language table
+    // maps it to the json parser, so it formats correctly on its own (measured).
+    // Splitting the batch also meant one of the two spawns could receive zero
+    // files, which is the error above.
+    (0, node_child_process_1.execSync)(`node ${quoteForShell(prettierPath)} --write ${listDifferentArg}-- ${patterns
+        .map(quoteForShell)
+        .join(' ')}`, {
+        cwd,
+        stdio: [0, 1, 2],
+        windowsHide: true,
+    });
+}
+function checkWithPrettier(patterns) {
+    const prettierPath = getPrettierPath();
+    return new Promise((resolve, reject) => {
+        (0, node_child_process_1.exec)(`node ${quoteForShell(prettierPath)} --list-different -- ${patterns
+            .map(quoteForShell)
+            .join(' ')}`, { encoding: 'utf-8', windowsHide: true, maxBuffer: shared_1.FORMATTER_MAX_BUFFER }, (error, stdout) => {
+            if (error) {
+                // As the oxfmt sibling: a spawn failure, kill or maxBuffer overrun reports a
+                // string `code` or none. Prettier signals "files differ" numerically, so
+                // treating these as a file list would pass `format:check` on a formatter
+                // that never ran.
+                if (typeof error['code'] !== 'number') {
+                    reject(new Error(`prettier could not be run to completion (${error['code'] ?? error.signal ?? 'unknown'}): ${error.message}`));
+                    return;
+                }
+                // Only `Mismatch` means "files differ", as in `checkWithOxfmt`. `Failure`
+                // still prints the files prettier got through - measured, one differing plus
+                // one unparseable exits 2 with the differing file on stdout - so reading
+                // stdout there would swallow the syntax error.
+                if (error['code'] !== 1 /* PrettierExitCode.Mismatch */ ||
+                    stdout.length === 0) {
+                    reject(error);
+                    return;
+                }
+                resolve(stdout.trim().split('\n'));
+            }
+            else {
+                resolve([]);
+            }
+        });
+    });
+}
+let prettierPath;
+function getPrettierPath() {
+    if (prettierPath) {
+        return prettierPath;
+    }
+    const { packageJson, path: packageJsonPath } = (0, package_json_1.readModulePackageJson)('prettier');
+    const bin = packageJson.bin;
+    const binPath = typeof bin === 'string' ? bin : bin?.['prettier'];
+    if (!binPath) {
+        throw new Error(`Could not find prettier binary in ${packageJsonPath}`);
+    }
+    prettierPath = (0, node_path_1.resolve)((0, node_path_1.dirname)(packageJsonPath), binPath);
+    return prettierPath;
+}
+let useListDifferent;
+/**
+ * Determines if --list-different should be used with --write.
+ * Prettier 4+ and 3.6.x with experimental CLI don't support combining these flags.
+ */
+function shouldUseListDifferent() {
+    if (useListDifferent !== undefined) {
+        return useListDifferent;
+    }
+    try {
+        const { packageJson } = (0, package_json_1.readModulePackageJson)('prettier');
+        const prettierMajor = (0, semver_1.major)(packageJson.version);
+        const isExperimentalCli = process.env.PRETTIER_EXPERIMENTAL_CLI === '1';
+        useListDifferent = prettierMajor < 4 && !isExperimentalCli;
+    }
+    catch {
+        useListDifferent = false;
+    }
+    return useListDifferent;
+}
+/**
+ * Quote a pattern for prettier's shell-based exec calls; oxfmt uses execFile
+ * and takes raw paths.
+ *
+ * Exported so `nx format` can size its chunks against the quoted length -
+ * patterns are chunked before they get here, and quoting grows each one.
+ */
+function quoteForShell(pattern) {
+    // Interpolated into a command string, so every character special *inside
+    // double quotes* needs escaping, not just `$`: a backtick substitutes, `"`
+    // closes the quoting, `\` escapes what follows. One pass over the original,
+    // since `String.replace` never re-scans what it inserted.
+    const escaped = process.platform !== 'win32'
+        ? pattern.replace(/([\\"`$])/g, '\\$1')
+        : pattern;
+    return `"${escaped}"`;
+}

package/dist/src/utils/formatters/shared.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Formatters list every mismatching path on stdout, which overruns Node's 1MB
+ * default on a large workspace.
+ */
+export declare const FORMATTER_MAX_BUFFER: number;

package/dist/src/utils/formatters/shared.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FORMATTER_MAX_BUFFER = void 0;
+/**
+ * Formatters list every mismatching path on stdout, which overruns Node's 1MB
+ * default on a large workspace.
+ */
+exports.FORMATTER_MAX_BUFFER = 50 * 1024 * 1024;

package/dist/src/utils/ignore.d.ts

@@ -62,7 +62,7 @@ export declare function createIgnoreChainResolver(read: (path: string) => string
  * that same note. Here they are simply the entry's matchers: any one excluding
  * wins, and a negation counts only if none excluded.
  *
- * Two preconditions, both satisfied by a pruning walk and neither enforced:
+ * Two preconditions, neither enforced here:
  *
  * - `filePath` is workspace-relative POSIX and must sit under every `dir` in the
  *   chain, which holds when the chain came from that file's own directory.
@@ -70,11 +70,28 @@ export declare function createIgnoreChainResolver(read: (path: string) => string
  *   re-include a file inside an excluded directory, and this does not implement
  *   that rule: asked directly about `dist/keep.ts` with a root `dist/` and a
  *   nested `dist/.gitignore` holding `!keep.ts`, it answers "not ignored" where
- *   git says ignored (measured). `visitNotIgnoredFiles` never asks, because it
- *   prunes `dist/` before descending - which is what makes its answers match
- *   git, and why that pruning is load-bearing for correctness rather than speed.
+ *   git says ignored (measured). A pruning walk like `visitNotIgnoredFiles`
+ *   satisfies it by never asking about anything under `dist/`; a per-file
+ *   caller cannot, so it goes through `createAncestorAwareIgnoreChecker`,
+ *   which checks the ancestors before asking the chain.
  */
 export declare function isIgnoredByChain(chain: ScopedIgnoreMatcher[], filePath: string): boolean;
+/**
+ * The chain's answers plus git's excluded-ancestor rule: nothing inside an
+ * ignored directory can be re-included, so a nested negation must not
+ * resurrect a file whose ancestor an outer file excluded - the case
+ * `isIgnoredByChain` alone gets wrong (see its second precondition). The
+ * oxfmt CLI follows the same rule (measured against 0.60.0: a scan skips a
+ * nested `!keep.ts` under a root-ignored `dist/`), so every per-file caller -
+ * the cascading tree checkers and the disk-backed resolver in
+ * `formatters/oxfmt.ts` - goes through here.
+ *
+ * A directory's own ignore files cannot un-ignore the directory itself, so
+ * its verdict comes from its parent's chain - probed with a trailing slash,
+ * which is what makes a directory-only pattern like `dist/` match. Verdicts
+ * are memoized per directory, so a batch of files shares its ancestor walks.
+ */
+export declare function createAncestorAwareIgnoreChecker(resolve: (dir: string) => ScopedIgnoreMatcher[]): TreeIgnoreChecker;
 /**
  * Directories that should never be walked, whatever the workspace's own ignore
  * files say - `node_modules`, `.git`, the nx caches.
@@ -88,7 +105,7 @@ export declare function isIgnoredByChain(chain: ScopedIgnoreMatcher[], filePath:
  */
 export declare function isAlwaysIgnored(path: string): boolean;
 /**
- * The chain bound to a tree, as predicates over workspace-relative POSIX paths.
+ * A chain's answers as predicates over workspace-relative POSIX paths.
  *
  * Files and directories are asked separately because the answers differ: a
  * pattern is only directory-only if it ends in a slash, and `ignore` will not
@@ -123,6 +140,31 @@ export declare function createGitIgnoreChecker(tree: Tree): TreeIgnoreChecker;
  * Reads from the tree rather than disk, as above.
  */
 export declare function createPrettierIgnoreChecker(tree: Tree): TreeIgnoreChecker;
+/**
+ * What oxfmt ignores: prettier's two files, but resolved from each file's own
+ * directory upwards rather than the workspace root - measured against the
+ * oxfmt 0.60.0 CLI, which differs from prettier on exactly that axis. Still
+ * one matcher per file rather than merged.
+ *
+ * A config's `ignorePatterns` is not an ignore file and is not read here;
+ * `formatFilesWithOxfmt` applies it rooted at that config's directory.
+ */
+export declare function createOxfmtIgnoreChecker(tree: Tree): TreeIgnoreChecker;
+/**
+ * Exported, unlike git's and prettier's, because oxfmt has two consumers:
+ * this tree-backed checker and the disk-backed resolver in
+ * `formatters/oxfmt.ts`. A shared value is the only thing that keeps them
+ * agreeing, so do not restate these three anywhere.
+ *
+ * `satisfies` rather than an annotation keeps the values literal - an
+ * annotation widens `cascade` and `merge` to `boolean` (measured in the
+ * declaration emit).
+ */
+export declare const OXFMT_IGNORE_OPTIONS: {
+    filenames: string[];
+    cascade: true;
+    merge: false;
+};
 /**
  * `path.dirname` for the workspace-relative POSIX paths the chain is keyed by,
  * except that the workspace root is `''` rather than `.` - that is the key

package/dist/src/utils/ignore.js

@@ -1,11 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.OXFMT_IGNORE_OPTIONS = void 0;
 exports.getIgnoreObject = getIgnoreObject;
 exports.createIgnoreChainResolver = createIgnoreChainResolver;
 exports.isIgnoredByChain = isIgnoredByChain;
+exports.createAncestorAwareIgnoreChecker = createAncestorAwareIgnoreChecker;
 exports.isAlwaysIgnored = isAlwaysIgnored;
 exports.createGitIgnoreChecker = createGitIgnoreChecker;
 exports.createPrettierIgnoreChecker = createPrettierIgnoreChecker;
+exports.createOxfmtIgnoreChecker = createOxfmtIgnoreChecker;
 exports.posixDirname = posixDirname;
 exports.addEntryToGitIgnore = addEntryToGitIgnore;
 const ignore = require("ignore");
@@ -93,7 +96,7 @@ function createIgnoreChainResolver(read, filenames, merge) {
  * that same note. Here they are simply the entry's matchers: any one excluding
  * wins, and a negation counts only if none excluded.
  *
- * Two preconditions, both satisfied by a pruning walk and neither enforced:
+ * Two preconditions, neither enforced here:
  *
  * - `filePath` is workspace-relative POSIX and must sit under every `dir` in the
  *   chain, which holds when the chain came from that file's own directory.
@@ -101,9 +104,10 @@ function createIgnoreChainResolver(read, filenames, merge) {
  *   re-include a file inside an excluded directory, and this does not implement
  *   that rule: asked directly about `dist/keep.ts` with a root `dist/` and a
  *   nested `dist/.gitignore` holding `!keep.ts`, it answers "not ignored" where
- *   git says ignored (measured). `visitNotIgnoredFiles` never asks, because it
- *   prunes `dist/` before descending - which is what makes its answers match
- *   git, and why that pruning is load-bearing for correctness rather than speed.
+ *   git says ignored (measured). A pruning walk like `visitNotIgnoredFiles`
+ *   satisfies it by never asking about anything under `dist/`; a per-file
+ *   caller cannot, so it goes through `createAncestorAwareIgnoreChecker`,
+ *   which checks the ancestors before asking the chain.
  */
 function isIgnoredByChain(chain, filePath) {
     for (const { dir, matchers } of chain) {
@@ -122,6 +126,45 @@ function isIgnoredByChain(chain, filePath) {
     }
     return false;
 }
+/**
+ * The chain's answers plus git's excluded-ancestor rule: nothing inside an
+ * ignored directory can be re-included, so a nested negation must not
+ * resurrect a file whose ancestor an outer file excluded - the case
+ * `isIgnoredByChain` alone gets wrong (see its second precondition). The
+ * oxfmt CLI follows the same rule (measured against 0.60.0: a scan skips a
+ * nested `!keep.ts` under a root-ignored `dist/`), so every per-file caller -
+ * the cascading tree checkers and the disk-backed resolver in
+ * `formatters/oxfmt.ts` - goes through here.
+ *
+ * A directory's own ignore files cannot un-ignore the directory itself, so
+ * its verdict comes from its parent's chain - probed with a trailing slash,
+ * which is what makes a directory-only pattern like `dist/` match. Verdicts
+ * are memoized per directory, so a batch of files shares its ancestor walks.
+ */
+function createAncestorAwareIgnoreChecker(resolve) {
+    const ignoredDirs = new Map();
+    const isIgnoredDirectory = (dir) => {
+        if (dir === '') {
+            return false;
+        }
+        const cached = ignoredDirs.get(dir);
+        if (cached !== undefined) {
+            return cached;
+        }
+        const parent = posixDirname(dir);
+        const ignored = isIgnoredDirectory(parent) ||
+            isIgnoredByChain(resolve(parent), `${dir}/`);
+        ignoredDirs.set(dir, ignored);
+        return ignored;
+    };
+    return {
+        isIgnoredFile: (filePath) => {
+            const dir = posixDirname(filePath);
+            return (isIgnoredDirectory(dir) || isIgnoredByChain(resolve(dir), filePath));
+        },
+        isIgnoredDirectory,
+    };
+}
 let alwaysIgnored;
 /**
  * Directories that should never be walked, whatever the workspace's own ignore
@@ -174,16 +217,55 @@ function createPrettierIgnoreChecker(tree) {
         merge: false,
     });
 }
+/**
+ * What oxfmt ignores: prettier's two files, but resolved from each file's own
+ * directory upwards rather than the workspace root - measured against the
+ * oxfmt 0.60.0 CLI, which differs from prettier on exactly that axis. Still
+ * one matcher per file rather than merged.
+ *
+ * A config's `ignorePatterns` is not an ignore file and is not read here;
+ * `formatFilesWithOxfmt` applies it rooted at that config's directory.
+ */
+function createOxfmtIgnoreChecker(tree) {
+    return createTreeIgnoreChecker(tree, exports.OXFMT_IGNORE_OPTIONS);
+}
+/**
+ * Exported, unlike git's and prettier's, because oxfmt has two consumers:
+ * this tree-backed checker and the disk-backed resolver in
+ * `formatters/oxfmt.ts`. A shared value is the only thing that keeps them
+ * agreeing, so do not restate these three anywhere.
+ *
+ * `satisfies` rather than an annotation keeps the values literal - an
+ * annotation widens `cascade` and `merge` to `boolean` (measured in the
+ * declaration emit).
+ */
+exports.OXFMT_IGNORE_OPTIONS = {
+    filenames: ['.gitignore', '.prettierignore'],
+    cascade: true,
+    merge: false,
+};
 function createTreeIgnoreChecker(tree, { filenames, cascade, merge }) {
     const resolve = createIgnoreChainResolver((path) => tree.read(path, 'utf-8'), filenames, merge);
-    // `probe` may carry a trailing slash; `path` never does. The chain is keyed by
-    // real directories, and `posixDirname('dist/')` is `'dist'` rather than the
-    // parent, so the lookup always uses the slash-less form.
-    const check = (path, probe) => isAlwaysIgnored(probe) ||
-        isIgnoredByChain(resolve(cascade ? posixDirname(path) : ''), probe);
+    if (cascade) {
+        // Cascading resolution and the excluded-ancestor rule travel together:
+        // both come from git, and the one cascading tool that is not git - oxfmt -
+        // applies both (measured, see `createAncestorAwareIgnoreChecker`).
+        const checker = createAncestorAwareIgnoreChecker(resolve);
+        return {
+            isIgnoredFile: (path) => isAlwaysIgnored(path) || checker.isIgnoredFile(path),
+            // The trailing slash is what makes a directory-only pattern like `dist/`
+            // match - `ignore` will not match it against the bare `dist`.
+            isIgnoredDirectory: (path) => isAlwaysIgnored(`${path}/`) || checker.isIgnoredDirectory(path),
+        };
+    }
+    // Root-only: the whole chain is the root's, so no ancestor holds ignore
+    // files of its own, and within one matcher `ignore` itself refuses to
+    // re-include under an excluded directory (measured). Nothing is left for an
+    // ancestor walk to add.
+    const check = (probe) => isAlwaysIgnored(probe) || isIgnoredByChain(resolve(''), probe);
     return {
-        isIgnoredFile: (path) => check(path, path),
-        isIgnoredDirectory: (path) => check(path, `${path}/`),
+        isIgnoredFile: (path) => check(path),
+        isIgnoredDirectory: (path) => check(`${path}/`),
     };
 }
 /**

package/dist/src/utils/write-formatted-json-file.d.ts

@@ -1,6 +1,7 @@
 import { type JsonWriteOptions } from './fileutils';
 /**
- * Writes a JSON file, formatting with Prettier if available, otherwise
- * falling back to standard JSON serialization.
+ * Writes a JSON file, formatting it with whichever formatter the workspace is
+ * configured for, and falling back to standard JSON serialization when there
+ * is none or it cannot format the file.
  */
 export declare function writeFormattedJsonFile<T extends object = object>(filePath: string, content: T, options?: JsonWriteOptions): Promise<void>;

package/dist/src/utils/write-formatted-json-file.js

@@ -2,16 +2,17 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.writeFormattedJsonFile = writeFormattedJsonFile;
 const node_fs_1 = require("node:fs");
-const format_changed_files_with_prettier_if_available_1 = require("../generators/internal-utils/format-changed-files-with-prettier-if-available");
+const format_changed_files_1 = require("../generators/internal-utils/format-changed-files");
 const json_1 = require("./json");
 const fileutils_1 = require("./fileutils");
 const workspace_root_1 = require("./workspace-root");
 /**
- * Writes a JSON file, formatting with Prettier if available, otherwise
- * falling back to standard JSON serialization.
+ * Writes a JSON file, formatting it with whichever formatter the workspace is
+ * configured for, and falling back to standard JSON serialization when there
+ * is none or it cannot format the file.
  */
 async function writeFormattedJsonFile(filePath, content, options) {
-    const formattedContent = await (0, format_changed_files_with_prettier_if_available_1.formatFilesWithPrettierIfAvailable)([{ path: filePath, content: (0, json_1.serializeJson)(content) }], workspace_root_1.workspaceRoot, { silent: true });
+    const formattedContent = await (0, format_changed_files_1.formatFileContents)([{ path: filePath, content: (0, json_1.serializeJson)(content) }], workspace_root_1.workspaceRoot, { silent: true });
     if (formattedContent.has(filePath)) {
         (0, node_fs_1.writeFileSync)(filePath, formattedContent.get(filePath), {
             encoding: 'utf-8',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nx",
-  "version": "23.2.0-beta.8",
+  "version": "23.2.0-beta.9",
   "private": false,
   "type": "commonjs",
   "description": "The core Nx plugin contains the core functionality of Nx like the project graph, nx commands and task orchestration.",
@@ -185,16 +185,16 @@
     }
   },
   "optionalDependencies": {
-    "@nx/nx-darwin-arm64": "23.2.0-beta.8",
-    "@nx/nx-darwin-x64": "23.2.0-beta.8",
-    "@nx/nx-freebsd-x64": "23.2.0-beta.8",
-    "@nx/nx-linux-arm-gnueabihf": "23.2.0-beta.8",
-    "@nx/nx-linux-arm64-gnu": "23.2.0-beta.8",
-    "@nx/nx-linux-arm64-musl": "23.2.0-beta.8",
-    "@nx/nx-linux-x64-gnu": "23.2.0-beta.8",
-    "@nx/nx-linux-x64-musl": "23.2.0-beta.8",
-    "@nx/nx-win32-arm64-msvc": "23.2.0-beta.8",
-    "@nx/nx-win32-x64-msvc": "23.2.0-beta.8"
+    "@nx/nx-darwin-arm64": "23.2.0-beta.9",
+    "@nx/nx-darwin-x64": "23.2.0-beta.9",
+    "@nx/nx-freebsd-x64": "23.2.0-beta.9",
+    "@nx/nx-linux-arm-gnueabihf": "23.2.0-beta.9",
+    "@nx/nx-linux-arm64-gnu": "23.2.0-beta.9",
+    "@nx/nx-linux-arm64-musl": "23.2.0-beta.9",
+    "@nx/nx-linux-x64-gnu": "23.2.0-beta.9",
+    "@nx/nx-linux-x64-musl": "23.2.0-beta.9",
+    "@nx/nx-win32-arm64-msvc": "23.2.0-beta.9",
+    "@nx/nx-win32-x64-msvc": "23.2.0-beta.9"
   },
   "nx-migrations": {
     "migrations": "./migrations.json",

package/dist/src/generators/internal-utils/format-changed-files-with-prettier-if-available.js

@@ -1,88 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.formatChangedFilesWithPrettierIfAvailable = formatChangedFilesWithPrettierIfAvailable;
-exports.formatFilesWithPrettierIfAvailable = formatFilesWithPrettierIfAvailable;
-const tslib_1 = require("tslib");
-const path = tslib_1.__importStar(require("path"));
-const is_using_prettier_1 = require("../../utils/is-using-prettier");
-const path_1 = require("../../utils/path");
-const installation_directory_1 = require("../../utils/installation-directory");
-/**
- * Formats all the created or updated files using Prettier
- * @param tree - the file system tree
- *
- * @remarks
- * Set the environment variable `NX_SKIP_FORMAT` to `true` to skip Prettier
- * formatting. This is useful for repositories that use alternative formatters
- * like Biome, dprint, or have custom formatting requirements.
- */
-async function formatChangedFilesWithPrettierIfAvailable(tree, options) {
-    if (process.env.NX_SKIP_FORMAT === 'true') {
-        return;
-    }
-    const excludedPaths = options?.excludePaths
-        ? new Set(Array.from(options.excludePaths, path_1.normalizePath))
-        : undefined;
-    const files = new Set(tree
-        .listChanges()
-        .filter((file) => file.type !== 'DELETE' &&
-        !excludedPaths?.has((0, path_1.normalizePath)(file.path))));
-    const results = await formatFilesWithPrettierIfAvailable(Array.from(files), tree.root, options);
-    for (const [path, content] of results) {
-        tree.write(path, content);
-    }
-}
-async function formatFilesWithPrettierIfAvailable(files, root, options) {
-    const results = new Map();
-    // Check here as well for direct callers of this function
-    if (process.env.NX_SKIP_FORMAT === 'true' || files.length === 0) {
-        return results;
-    }
-    let prettier;
-    try {
-        const prettierPath = require.resolve('prettier', {
-            paths: [...(0, installation_directory_1.getNxRequirePaths)(root), __dirname],
-        });
-        prettier = require(prettierPath);
-        /**
-         * Even after we discovered prettier in node_modules, we need to be sure that the user is intentionally using prettier
-         * before proceeding to format with it.
-         */
-        if (!(0, is_using_prettier_1.isUsingPrettier)(root)) {
-            return results;
-        }
-    }
-    catch { }
-    if (!prettier) {
-        return results;
-    }
-    await Promise.all(Array.from(files).map(async (file) => {
-        try {
-            const systemPath = path.join(root, file.path);
-            let options = {
-                filepath: systemPath,
-            };
-            const resolvedOptions = await prettier.resolveConfig(systemPath, {
-                editorconfig: true,
-            });
-            if (!resolvedOptions) {
-                return;
-            }
-            options = {
-                ...options,
-                ...resolvedOptions,
-            };
-            const support = await prettier.getFileInfo(systemPath, options);
-            if (support.ignored || !support.inferredParser) {
-                return;
-            }
-            results.set(file.path, await prettier.format(file.content.toString('utf-8'), options));
-        }
-        catch (e) {
-            if (!options?.silent) {
-                console.warn(`Could not format ${file.path}. Error: "${e.message}"`);
-            }
-        }
-    }));
-    return results;
-}

package/dist/src/utils/is-using-prettier.d.ts

@@ -1,3 +0,0 @@
-import type { Tree } from '../generators/tree';
-export declare function isUsingPrettier(root: string): boolean;
-export declare function isUsingPrettierInTree(tree: Tree): boolean;