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

package/dist/src/migrations/update-23-2-0/set-cache-on-executor-target-defaults.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = update;
 const executor_utils_1 = require("../../command-line/run/executor-utils");
-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("../../generators/utils/json");
 const project_configuration_1 = require("../../generators/utils/project-configuration");
 const path_1 = require("../../utils/path");
@@ -67,7 +67,7 @@ async function update(tree) {
         return;
     }
     (0, project_configuration_1.updateNxJson)(tree, nxJson);
-    await (0, format_changed_files_with_prettier_if_available_1.formatChangedFilesWithPrettierIfAvailable)(tree);
+    await (0, format_changed_files_1.formatChangedFiles)(tree);
 }
 /**
  * Whether `cache: true` can be written onto `key` without changing behavior for

package/dist/src/nx-cloud/generators/connect-to-nx-cloud/connect-to-nx-cloud.js

@@ -6,7 +6,7 @@ const child_process_1 = require("child_process");
 const output_1 = require("../../../utils/output");
 const json_1 = require("../../../generators/utils/json");
 const nx_json_1 = require("../../../generators/utils/nx-json");
-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 url_shorten_1 = require("../../utilities/url-shorten");
 const get_cloud_options_1 = require("../../utilities/get-cloud-options");
 const path_1 = require("path");
@@ -137,14 +137,14 @@ async function connectToNxCloud(tree, schema, nxJson = (0, nx_json_1.readNxJson)
     }
     if (responseFromCreateNxCloudWorkspaceV2) {
         addNxCloudIdToNxJson(tree, responseFromCreateNxCloudWorkspaceV2?.nxCloudId, schema.directory);
-        await (0, format_changed_files_with_prettier_if_available_1.formatChangedFilesWithPrettierIfAvailable)(tree, {
+        await (0, format_changed_files_1.formatChangedFiles)(tree, {
             silent: schema.hideFormatLogs,
         });
         return responseFromCreateNxCloudWorkspaceV2.nxCloudId;
     }
     else if (responseFromCreateNxCloudWorkspaceV1) {
         addNxCloudAccessTokenToNxJson(tree, responseFromCreateNxCloudWorkspaceV1?.token, schema.directory);
-        await (0, format_changed_files_with_prettier_if_available_1.formatChangedFilesWithPrettierIfAvailable)(tree, {
+        await (0, format_changed_files_1.formatChangedFiles)(tree, {
             silent: schema.hideFormatLogs,
         });
         return responseFromCreateNxCloudWorkspaceV1.token;

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

@@ -1,4 +1,10 @@
-export declare function chunkify(target: string[], maxChunkLength?: number): string[][];
+export declare function chunkify(target: string[], maxChunkLength?: number, 
+/**
+ * How long each entry will be once it reaches the command line. Callers that
+ * quote or escape afterwards pass that transformation's length here, so the
+ * chunk is sized against what is actually spawned rather than the raw string.
+ */
+measure?: (item: string) => number): string[][];
 /**
  * Get the maximum length of a command-line argument string based on current platform
  *

package/dist/src/utils/chunkify.js

@@ -3,22 +3,29 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.chunkify = chunkify;
 exports.getMaxArgLength = getMaxArgLength;
 const TERMINAL_SIZE = getMaxArgLength();
-function chunkify(target, maxChunkLength = TERMINAL_SIZE - 500) {
+function chunkify(target, maxChunkLength = TERMINAL_SIZE - 500, 
+/**
+ * How long each entry will be once it reaches the command line. Callers that
+ * quote or escape afterwards pass that transformation's length here, so the
+ * chunk is sized against what is actually spawned rather than the raw string.
+ */
+measure = (item) => item.length) {
     const chunks = [];
     let currentChunk = [];
     let currentChunkLength = 0;
     for (const file of target) {
+        const length = measure(file);
         if (
         // Prevent empty chunk if first file path is longer than maxChunkLength
         currentChunk.length &&
             // +1 accounts for the space between file names
-            currentChunkLength + file.length + 1 >= maxChunkLength) {
+            currentChunkLength + length + 1 >= maxChunkLength) {
             chunks.push(currentChunk);
             currentChunk = [];
             currentChunkLength = 0;
         }
         currentChunk.push(file);
-        currentChunkLength += file.length + 1;
+        currentChunkLength += length + 1;
     }
     chunks.push(currentChunk);
     return chunks;

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

@@ -0,0 +1,13 @@
+import type { Tree } from '../../generators/tree';
+/**
+ * Adding a member here does NOT reliably break compilation: the repo builds
+ * with `strict: false`, so a `switch` that omits one is not an error. The
+ * `never` assertions and type-keyed tables that do catch it fail immediately
+ * inside `packages/nx`, but the ones in devkit and `@nx/js` read the type from
+ * its emitted declarations, so those only fail once it has been rebuilt.
+ */
+export type FormatterType = 'prettier' | 'oxfmt';
+/** Test-only: the warn-once flag is module state and would leak between cases. */
+export declare function resetFormatterWarningsForTesting(): void;
+export declare function detectFormatter(root: string): FormatterType | null;
+export declare function detectFormatterInTree(tree: Tree): FormatterType | null;

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

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resetFormatterWarningsForTesting = resetFormatterWarningsForTesting;
+exports.detectFormatter = detectFormatter;
+exports.detectFormatterInTree = detectFormatterInTree;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const json_1 = require("../../generators/utils/json");
+const fileutils_1 = require("../fileutils");
+const oxfmt_1 = require("./oxfmt");
+const prettier_1 = require("./prettier");
+const logger_1 = require("../logger");
+// Once per process: detection runs on every one of 200+ `formatFiles` call sites.
+let warnedBothConfigured = false;
+function warnBothConfigured() {
+    warnedBothConfigured = true;
+    logger_1.logger.warn('Both an oxfmt and a prettier config were found. Nx is formatting with ' +
+        'oxfmt. Delete the config you are not using to make the choice ' +
+        'explicit: https://nx.dev/docs/reference/code-formatting');
+}
+/** Test-only: the warn-once flag is module state and would leak between cases. */
+function resetFormatterWarningsForTesting() {
+    warnedBothConfigured = false;
+}
+function detectFormatter(root) {
+    if ((0, oxfmt_1.isUsingOxfmt)(root)) {
+        // Flag first, so the lookup stops repeating once we have warned.
+        if (!warnedBothConfigured && (0, prettier_1.isUsingPrettier)(root)) {
+            warnBothConfigured();
+        }
+        return 'oxfmt';
+    }
+    if ((0, prettier_1.isUsingPrettier)(root)) {
+        return 'prettier';
+    }
+    // Neither is configured. Both formatters run on their defaults, so a
+    // dependency declared in the root package.json is the only statement of
+    // intent an unconfigured workspace gives. #30426 ruled out treating prettier
+    // as *resolvable in node_modules*, which a declared dependency is not.
+    const packageJsonPath = (0, node_path_1.join)(root, 'package.json');
+    if ((0, node_fs_1.existsSync)(packageJsonPath)) {
+        return detectFormatterFromDependencies((0, fileutils_1.readJsonFile)(packageJsonPath));
+    }
+    return null;
+}
+function detectFormatterInTree(tree) {
+    if ((0, oxfmt_1.isUsingOxfmtInTree)(tree)) {
+        if (!warnedBothConfigured && (0, prettier_1.isUsingPrettierInTree)(tree)) {
+            warnBothConfigured();
+        }
+        return 'oxfmt';
+    }
+    if ((0, prettier_1.isUsingPrettierInTree)(tree)) {
+        return 'prettier';
+    }
+    // See detectFormatter: a declared dependency is the fallback for both.
+    if (tree.exists('package.json')) {
+        return detectFormatterFromDependencies((0, json_1.readJson)(tree, 'package.json'));
+    }
+    return null;
+}
+/** oxfmt first, matching the precedence the config files already have. */
+function detectFormatterFromDependencies(packageJson) {
+    if (hasDependency(packageJson, 'oxfmt')) {
+        return 'oxfmt';
+    }
+    if (hasDependency(packageJson, 'prettier')) {
+        return 'prettier';
+    }
+    return null;
+}
+function hasDependency(packageJson, name) {
+    return Boolean(packageJson.dependencies?.[name] ?? packageJson.devDependencies?.[name]);
+}

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

@@ -0,0 +1,32 @@
+import type { Tree } from '../../generators/tree';
+/**
+ * Config filenames oxfmt *discovers* - narrower than the set `-c` accepts.
+ * Measured against 0.60.0: `oxfmt.config.{js,cjs,mjs,cts}` load when named
+ * but are never searched for, so treating one as config would format on
+ * options oxfmt ignores. No precedence order - oxfmt fails with
+ * "Both '<a>' and '<b>' found in <dir>" when a directory holds two.
+ */
+export declare const oxfmtConfigFiles: string[];
+export declare function isUsingOxfmt(root: string): boolean;
+export declare function isUsingOxfmtInTree(tree: Tree): boolean;
+export declare function getOxfmtBinPath(): string;
+export declare function writeWithOxfmt(patterns: string[], cwd?: string): void;
+export declare function checkWithOxfmt(patterns: string[]): Promise<string[]>;
+/**
+ * Nothing is written to disk: staging files inside the workspace would race the
+ * daemon's watcher and the project graph mid-generator.
+ *
+ * A path is absent from the result when oxfmt has no parser for it, an ignore
+ * file covers it, or it is already formatted. One unparseable file fails only
+ * itself; the rest of the batch still applies.
+ */
+export declare function formatFilesWithOxfmt(files: {
+    path: string;
+    content: string;
+}[], workspaceRoot: string, seedConfig?: {
+    name: string;
+    content: string;
+}, rootConfigNames?: readonly string[], read?: (relativePath: string) => string | null | undefined): Promise<{
+    formatted: Map<string, string>;
+    errors?: string[];
+}>;