nx 23.2.0-beta.1 → 23.2.0-beta.2

package/dist/src/analytics/analytics.d.ts

@@ -1,6 +1,12 @@
 import type { EventDimensions } from '../native';
 export declare const customDimensions: EventDimensions;
 export type EventParameters = Partial<Record<EventDimensions[keyof EventDimensions], string | number | boolean>>;
+/**
+ * Fraction of sessions that report perf spans. Stamping this rate on a
+ * measure's detail (as the sampleRate dimension) opts it into sampling; see
+ * is_sampled_in in native/telemetry/service.rs. Multiply GA counts by 1/rate.
+ */
+export declare const PERF_SPAN_SAMPLE_RATE = 0.1;
 export declare function startAnalytics(): Promise<void>;
 export declare function reportNxAddCommand(packageName: string, version: string): void;
 export declare function reportNxGenerateCommand(generator: string): void;

package/dist/src/analytics/analytics.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.customDimensions = void 0;
+exports.PERF_SPAN_SAMPLE_RATE = exports.customDimensions = void 0;
 exports.startAnalytics = startAnalytics;
 exports.reportNxAddCommand = reportNxAddCommand;
 exports.reportNxGenerateCommand = reportNxGenerateCommand;
@@ -42,6 +42,12 @@ exports.customDimensions = native_1.IS_WASM
     ? null
     : (getEventDimensions?.() ?? null);
 let _telemetryInitialized = false;
+/**
+ * Fraction of sessions that report perf spans. Stamping this rate on a
+ * measure's detail (as the sampleRate dimension) opts it into sampling; see
+ * is_sampled_in in native/telemetry/service.rs. Multiply GA counts by 1/rate.
+ */
+exports.PERF_SPAN_SAMPLE_RATE = 0.1;
 async function startAnalytics() {
     // Analytics not supported on WASM
     if (native_1.IS_WASM) {

package/dist/src/analytics/index.d.ts

@@ -1 +1 @@
-export { customDimensions, EventParameters, startAnalytics, reportNxAddCommand, reportNxGenerateCommand, reportCommandRunEvent, reportEvent, flushAnalytics, } from './analytics';
+export { customDimensions, EventParameters, PERF_SPAN_SAMPLE_RATE, startAnalytics, reportNxAddCommand, reportNxGenerateCommand, reportCommandRunEvent, reportEvent, flushAnalytics, } from './analytics';

package/dist/src/analytics/index.js

@@ -1,8 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.flushAnalytics = exports.reportEvent = exports.reportCommandRunEvent = exports.reportNxGenerateCommand = exports.reportNxAddCommand = exports.startAnalytics = exports.customDimensions = void 0;
+exports.flushAnalytics = exports.reportEvent = exports.reportCommandRunEvent = exports.reportNxGenerateCommand = exports.reportNxAddCommand = exports.startAnalytics = exports.PERF_SPAN_SAMPLE_RATE = exports.customDimensions = void 0;
 var analytics_1 = require("./analytics");
 Object.defineProperty(exports, "customDimensions", { enumerable: true, get: function () { return analytics_1.customDimensions; } });
+Object.defineProperty(exports, "PERF_SPAN_SAMPLE_RATE", { enumerable: true, get: function () { return analytics_1.PERF_SPAN_SAMPLE_RATE; } });
 Object.defineProperty(exports, "startAnalytics", { enumerable: true, get: function () { return analytics_1.startAnalytics; } });
 Object.defineProperty(exports, "reportNxAddCommand", { enumerable: true, get: function () { return analytics_1.reportNxAddCommand; } });
 Object.defineProperty(exports, "reportNxGenerateCommand", { enumerable: true, get: function () { return analytics_1.reportNxGenerateCommand; } });

package/dist/src/command-line/init/implementation/angular/integrated-workspace.js

@@ -1,12 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.setupIntegratedWorkspace = setupIntegratedWorkspace;
-const child_process_1 = require("child_process");
-const package_manager_1 = require("../../../../utils/package-manager");
+const child_process_1 = require("../../../../utils/child-process");
 function setupIntegratedWorkspace() {
-    const pmc = (0, package_manager_1.getPackageManagerCommand)();
-    (0, child_process_1.execSync)(`${pmc.exec} nx g @nx/angular:ng-add`, {
+    (0, child_process_1.runNxSync)(`g @nx/angular:ng-add`, {
         stdio: [0, 1, 2],
-        windowsHide: true,
     });
 }

package/dist/src/command-line/init/implementation/angular/legacy-angular-versions.js

@@ -107,6 +107,9 @@ async function getLegacyMigrationFunctionIfApplicable(repoRoot, options) {
             unscopedPkgName,
         }, pmc);
         output_1.output.log({ title: '📝 Setting up workspace' });
+        // Intentionally not runNxSync: legacyMigrationCommand is either the Angular
+        // CLI (`ng g ...:ng-add`) or a version-pinned `nx@<version> init`, neither
+        // of which is the local nx that runNxSync would resolve.
         (0, child_process_1.execSync)(`${pmc.exec} ${legacyMigrationCommand}`, {
             stdio: [0, 1, 2],
             windowsHide: true,

package/dist/src/command-line/init/implementation/dot-nx/add-nx-scripts.js

@@ -69,7 +69,10 @@ function generateDotNxSetup(version) {
     (0, tree_1.flushChanges)(host.root, changes);
     // Ensure that the dot-nx installation is available.
     // This is needed when using a global nx with dot-nx, otherwise running any nx command using global command will fail due to missing modules.
-    // Pipe stderr so failures surface in telemetry instead of bare "Command failed: ./nx --version".
+    // Intentionally not runNxSync: when the repo has a package.json it would run
+    // `<pm> exec nx` instead of the wrapper, but this call must run the
+    // just-written wrapper itself so it bootstraps .nx/installation.
+    // Pipe stderr so failures surface in telemetry instead of bare "Command failed".
     try {
         (0, child_process_1.execSync)(getDotNxWrapperVersionCommand(), {
             stdio: ['ignore', 'ignore', 'pipe'],

package/dist/src/command-line/migrate/migrate.js

@@ -2307,6 +2307,10 @@ async function runMigration() {
                 process.env.npm_config_registry.match(/^https:\/\/registry\.(npmjs\.org|yarnpkg\.com)/)) {
                 delete process.env.npm_config_registry;
             }
+            // Intentionally not runNxSync: `p` is an nx CLI freshly installed into a
+            // temp dir by nxCliPath() (latest, or NX_MIGRATE_CLI_VERSION), so
+            // migrations run with an up-to-date migrate implementation instead of
+            // the workspace's current nx.
             return runOrReturnExitCode(() => (0, child_process_1.execSync)(`${p} _migrate ${process.argv.slice(3).join(' ')}`, {
                 stdio: ['inherit', 'inherit', 'inherit'],
                 windowsHide: true,

package/dist/src/command-line/nx-cloud/connect/view-logs.js

@@ -39,6 +39,8 @@ async function viewLogs() {
         return 1;
     }
     const pmc = (0, package_manager_1.getPackageManagerCommand)();
+    // Intentionally not runNxSync: this invokes the separate `nx-cloud` binary,
+    // not the nx CLI that runNxSync resolves.
     (0, child_process_1.execSync)(`${pmc.exec} nx-cloud upload-and-show-run-details`, {
         stdio: [0, 1, 2],
         windowsHide: true,

package/dist/src/command-line/show/show-target/inputs.js

@@ -1,185 +1,82 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.showTargetInputsHandler = showTargetInputsHandler;
-const workspace_root_1 = require("../../../utils/workspace-root");
-const handle_import_1 = require("../../../utils/handle-import");
-const utils_1 = require("./utils");
+const check_task_files_1 = require("../../../hasher/check-task-files");
+const utils_1 = require("../../../tasks-runner/utils");
+const utils_2 = require("./utils");
 // ── Handler ─────────────────────────────────────────────────────────
 async function showTargetInputsHandler(args) {
-    const t = await (0, utils_1.resolveTarget)(args);
-    const usesCustomHasher = (0, utils_1.hasCustomHasher)(t.projectName, t.targetName, t.graph);
-    if (usesCustomHasher) {
-        renderCustomHasherWarning(t.projectName, t.targetName, args);
+    const t = await (0, utils_2.resolveTarget)(args);
+    const { projectName, targetName, configuration } = t;
+    if ((0, utils_2.hasCustomHasher)(projectName, targetName, t.graph)) {
+        renderCustomHasherWarning(projectName, targetName, args);
         process.exitCode = 1;
         return;
     }
-    const hashInputs = await resolveInputFiles(t);
+    const taskId = (0, utils_1.createTaskId)(projectName, targetName, configuration);
+    const hashInputs = await (0, check_task_files_1.getTaskRawInputs)(taskId, {
+        projectGraph: t.graph,
+        nxJson: t.nxJson,
+    });
+    if (!hashInputs) {
+        throw new Error(`Could not find hash plan for task "${taskId}".`);
+    }
     if (args.check !== undefined) {
-        const checkItems = (0, utils_1.deduplicateFolderEntries)(args.check);
-        const results = checkItems.map((input) => resolveCheckFromInputs(input, t.projectName, t.targetName, hashInputs));
-        if (results.length >= 2) {
-            renderBatchCheckInputs(results, t.projectName, t.targetName);
-        }
-        else {
-            for (const data of results)
-                renderCheckInput(data);
-        }
-        for (const data of results) {
-            process.exitCode ||=
-                data.isInput || data.containedInputFiles.length ? 0 : 1;
-        }
+        const results = await checkInputs(taskId, args.check, hashInputs);
+        (0, utils_2.renderCheckResults)(results, projectName, targetName, 'input');
+        (0, utils_2.setCheckExitCode)(results);
         return;
     }
-    renderInputs({ project: t.projectName, target: t.targetName, ...hashInputs }, t.node.data.targets[t.targetName].inputs, args);
+    renderInputs({ project: projectName, target: targetName, ...hashInputs }, t.node.data.targets[targetName].inputs, args);
 }
-async function resolveInputFiles(t) {
-    const { projectName, targetName, configuration, graph, nxJson } = t;
-    const { HashPlanInspector } = (await (0, handle_import_1.handleImport)('../../../hasher/hash-plan-inspector.js', __dirname));
-    const inspector = new HashPlanInspector(graph, workspace_root_1.workspaceRoot, nxJson);
-    await inspector.init();
-    const plan = inspector.inspectTaskInputs({
-        project: projectName,
-        target: targetName,
-        configuration,
+// ── Data resolution ─────────────────────────────────────────────────
+async function checkInputs(taskId, check, hashInputs) {
+    // checkFilesAreInputs matches environment/runtime/external names against the
+    // raw argument and paths against the workspace-relative form, so both are
+    // passed through — it has no cwd of its own.
+    const candidates = (0, utils_2.deduplicateFolderEntries)(check).map((value) => ({
+        value,
+        path: (0, utils_2.normalizePath)(value),
+    }));
+    const { categories } = await (0, check_task_files_1.checkFilesAreInputs)(taskId, candidates);
+    return candidates.map(({ value, path }) => {
+        const category = categories.get(value);
+        return {
+            value,
+            file: path,
+            matched: !!category,
+            category,
+            contained: category ? [] : (0, utils_2.pathsUnder)(path, hashInputs.files),
+        };
     });
-    const targetConfig = graph.nodes[projectName]?.data?.targets?.[targetName];
-    const effectiveConfig = configuration ?? targetConfig?.defaultConfiguration;
-    const taskId = effectiveConfig
-        ? `${projectName}:${targetName}:${effectiveConfig}`
-        : `${projectName}:${targetName}`;
-    const result = plan[taskId];
-    if (!result) {
-        throw new Error(`Could not find hash plan for task "${taskId}". Available tasks: ${Object.keys(plan).join(', ')}`);
-    }
-    return result;
-}
-function resolveCheckFromInputs(rawValue, projectName, targetName, inputs) {
-    for (const [category, arr] of [
-        ['environment', inputs.environment],
-        ['runtime', inputs.runtime],
-        ['external', inputs.external],
-        ['depOutputs', inputs.depOutputs],
-    ]) {
-        if (arr.includes(rawValue)) {
-            return {
-                value: rawValue,
-                file: rawValue,
-                project: projectName,
-                target: targetName,
-                isInput: true,
-                matchedCategory: category,
-                containedInputFiles: [],
-            };
-        }
-    }
-    const fileToCheck = (0, utils_1.normalizePath)(rawValue);
-    const isFile = inputs.files.includes(fileToCheck);
-    let containedInputFiles = [];
-    if (!isFile) {
-        if (fileToCheck === '') {
-            containedInputFiles = inputs.files;
-        }
-        else {
-            const dirPrefix = fileToCheck.endsWith('/')
-                ? fileToCheck
-                : fileToCheck + '/';
-            containedInputFiles = inputs.files.filter((f) => f.startsWith(dirPrefix));
-        }
-    }
-    return {
-        value: rawValue,
-        file: fileToCheck,
-        project: projectName,
-        target: targetName,
-        isInput: isFile,
-        matchedCategory: isFile || containedInputFiles.length > 0
-            ? 'files'
-            : null,
-        containedInputFiles,
-    };
 }
 // ── Render ──────────────────────────────────────────────────────────
 function renderInputs(data, configuredInputs, args) {
     if (args.json) {
-        const jsonData = data;
-        const result = {};
-        for (const [k, v] of Object.entries(jsonData)) {
-            if (Array.isArray(v) && v.length === 0)
-                continue;
-            result[k] = v;
-        }
-        console.log(JSON.stringify(result, null, 2));
+        (0, utils_2.printJson)(data);
         return;
     }
-    const c = (0, utils_1.pc)();
+    const c = (0, utils_2.pc)();
     console.log(`${c.bold('Inputs for')} ${c.cyan(data.project)}:${c.green(data.target)}`);
-    if (configuredInputs && configuredInputs.length > 0) {
-        (0, utils_1.printList)('Configured inputs', configuredInputs.map((i) => typeof i === 'string' ? i : JSON.stringify(i)));
-    }
-    (0, utils_1.printList)('External dependencies', [...data.external].sort());
-    (0, utils_1.printList)('Runtime inputs', [...data.runtime].sort());
-    (0, utils_1.printList)('Environment variables', [...data.environment].sort());
-    (0, utils_1.printList)(`Files (${data.files.length})`, [...data.files, ...data.depOutputs].sort());
-}
-function renderCheckInput(data) {
-    const c = (0, utils_1.pc)();
-    const categoryLabel = data.matchedCategory
-        ? ` (${data.matchedCategory})`
-        : '';
-    if (data.isInput) {
-        console.log(`${c.green('✓')} ${c.bold(data.value)} is an input for ${c.cyan(data.project)}:${c.green(data.target)}${categoryLabel}`);
-    }
-    else if (data.containedInputFiles.length > 0) {
-        console.log(`${c.yellow('~')} ${c.bold(data.file)} is a directory containing ${c.bold(String(data.containedInputFiles.length))} input file(s) for ${c.cyan(data.project)}:${c.green(data.target)}`);
-        for (const f of [...data.containedInputFiles].sort())
-            console.log(`  ${f}`);
-    }
-    else {
-        console.log(`${c.red('✗')} ${c.bold(data.value)} is ${c.red('not')} an input for ${c.cyan(data.project)}:${c.green(data.target)}`);
-    }
-}
-function renderBatchCheckInputs(results, projectName, targetName) {
-    const c = (0, utils_1.pc)();
-    const label = `${c.cyan(projectName)}:${c.green(targetName)}`;
-    const matched = [];
-    const directories = [];
-    const unmatched = [];
-    for (const r of results) {
-        if (r.isInput) {
-            matched.push(r.value);
-        }
-        else if (r.containedInputFiles.length > 0) {
-            directories.push({ value: r.file, count: r.containedInputFiles.length });
-        }
-        else {
-            unmatched.push(r.value);
-        }
-    }
-    if (matched.length > 0 || directories.length > 0) {
-        console.log(`\n${c.green('✓')} These arguments were inputs for ${label}:`);
-        for (const v of matched)
-            console.log(`  ${v}`);
-        for (const d of directories) {
-            console.log(`  ${d.value} (directory containing ${d.count} input files)`);
-        }
-    }
-    if (unmatched.length > 0) {
-        console.log(`\n${c.red('✗')} These arguments were ${c.red('not')} inputs for ${label}:`);
-        for (const v of unmatched)
-            console.log(`  ${v}`);
+    if (configuredInputs?.length) {
+        (0, utils_2.printList)('Configured inputs', configuredInputs.map((i) => typeof i === 'string' ? i : JSON.stringify(i)));
     }
+    (0, utils_2.printList)('External dependencies', [...data.external].sort());
+    (0, utils_2.printList)('Runtime inputs', [...data.runtime].sort());
+    (0, utils_2.printList)('Environment variables', [...data.environment].sort());
+    (0, utils_2.printList)(`Files (${data.files.length})`, [...data.files, ...data.depOutputs].sort());
 }
 function renderCustomHasherWarning(projectName, targetName, args) {
-    const c = (0, utils_1.pc)();
-    const label = `${c.cyan(projectName)}:${c.green(targetName)}`;
+    const c = (0, utils_2.pc)();
     if (args.json) {
-        console.log(JSON.stringify({
+        (0, utils_2.printJson)({
             project: projectName,
             target: targetName,
             warning: 'This target uses a custom hasher. Configured inputs do not affect the cache hash.',
-        }, null, 2));
+        });
         return;
     }
+    const label = `${c.cyan(projectName)}:${c.green(targetName)}`;
     console.log(`\n${c.yellow('⚠')} ${label} uses a ${c.yellow('custom hasher')}.`);
     console.log(`  Configured inputs do not affect the cache hash for this target.`);
     console.log(`  The executor's hasher determines what is included in the hash.`);

package/dist/src/command-line/show/show-target/outputs.js

@@ -1,195 +1,70 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.showTargetOutputsHandler = showTargetOutputsHandler;
+const check_task_files_1 = require("../../../hasher/check-task-files");
 const utils_1 = require("../../../tasks-runner/utils");
-const workspace_root_1 = require("../../../utils/workspace-root");
 const utils_2 = require("./utils");
 // ── Handler ─────────────────────────────────────────────────────────
 async function showTargetOutputsHandler(args) {
     const t = await (0, utils_2.resolveTarget)(args);
-    const outputsData = resolveOutputsData(t);
+    const { projectName, targetName, configuration } = t;
+    const taskId = (0, utils_1.createTaskId)(projectName, targetName, configuration);
+    const outputs = await (0, check_task_files_1.getTaskOutputs)(taskId, {
+        projectGraph: t.graph,
+        nxJson: t.nxJson,
+    });
     if (args.check !== undefined) {
-        const checkItems = (0, utils_2.deduplicateFolderEntries)(args.check);
-        const results = checkItems.map((o) => resolveCheckOutputData(o, outputsData));
-        if (results.length >= 2) {
-            renderBatchCheckOutputs(results, outputsData.project, outputsData.target);
-        }
-        else {
-            for (const data of results)
-                renderCheckOutput(data);
-        }
-        for (const data of results) {
-            process.exitCode ||=
-                data.matchedOutput ||
-                    data.containedOutputPaths.length ||
-                    data.containedExpandedOutputs.length
-                    ? 0
-                    : 1;
-        }
+        const results = await checkOutputs(taskId, args.check, outputs);
+        (0, utils_2.renderCheckResults)(results, projectName, targetName, 'output');
+        (0, utils_2.setCheckExitCode)(results);
         return;
     }
-    renderOutputs(outputsData, args);
+    renderOutputs(projectName, targetName, outputs, args);
 }
-function resolveOutputsData(t) {
-    const { projectName, targetName, configuration, node } = t;
-    const resolvedOutputs = (0, utils_1.getOutputsForTargetAndConfiguration)({ project: projectName, target: targetName, configuration }, {}, node);
-    const targetConfig = node.data.targets?.[targetName];
-    const configuredOutputs = targetConfig?.outputs ?? [];
-    const mergedOptions = {
-        ...targetConfig?.options,
-        ...(configuration
-            ? targetConfig?.configurations?.[configuration]
-            : undefined),
-    };
-    const unresolvedOutputs = configuredOutputs.filter((o) => {
-        if (!/\{options\./.test(o))
-            return false;
-        const unresolved = o.match(/\{options\.([^}]+)\}/g);
-        return unresolved?.some((token) => {
-            const key = token.slice('{options.'.length, -1);
-            return mergedOptions[key] === undefined;
-        });
+// ── Data resolution ─────────────────────────────────────────────────
+async function checkOutputs(taskId, check, { resolved, expanded }) {
+    const checkItems = (0, utils_2.deduplicateFolderEntries)(check);
+    const paths = checkItems.map(utils_2.normalizePath);
+    // checkFilesAreOutputs handles exact, directory-prefix and glob matching (and
+    // `!` exclusions) through the same native engine the task runner uses.
+    const { matched } = await (0, check_task_files_1.checkFilesAreOutputs)(taskId, paths);
+    const matchedPaths = new Set(matched);
+    return checkItems.map((value, i) => {
+        const path = paths[i];
+        const isMatch = matchedPaths.has(path);
+        return {
+            value,
+            file: path,
+            matched: isMatch,
+            contained: isMatch
+                ? []
+                : [
+                    ...new Set([
+                        ...(0, utils_2.pathsUnder)(path, resolved),
+                        ...(0, utils_2.pathsUnder)(path, expanded),
+                    ]),
+                ],
+        };
     });
-    let expandedOutputs;
-    try {
-        const { expandOutputs } = require('../../../native');
-        expandedOutputs = expandOutputs(workspace_root_1.workspaceRoot, resolvedOutputs);
-    }
-    catch {
-        expandedOutputs = resolvedOutputs;
-    }
-    return {
-        project: projectName,
-        target: targetName,
-        outputPaths: resolvedOutputs,
-        expandedOutputs,
-        unresolvedOutputs,
-    };
-}
-function resolveCheckOutputData(rawFileToCheck, outputsData) {
-    const fileToCheck = (0, utils_2.normalizePath)(rawFileToCheck);
-    const { outputPaths, expandedOutputs } = outputsData;
-    let matchedOutput = null;
-    for (const outputPath of outputPaths) {
-        const normalizedOutput = outputPath.replace(/\\/g, '/');
-        if (fileToCheck === normalizedOutput ||
-            fileToCheck.startsWith(normalizedOutput + '/')) {
-            matchedOutput = outputPath;
-            break;
-        }
-    }
-    if (!matchedOutput && expandedOutputs.includes(fileToCheck)) {
-        matchedOutput = fileToCheck;
-    }
-    let containedOutputPaths = [];
-    let containedExpandedOutputs = [];
-    if (!matchedOutput) {
-        if (fileToCheck === '') {
-            containedOutputPaths = [...outputPaths];
-            containedExpandedOutputs = [...expandedOutputs];
-        }
-        else {
-            const dirPrefix = fileToCheck.endsWith('/')
-                ? fileToCheck
-                : fileToCheck + '/';
-            containedOutputPaths = outputPaths.filter((o) => o.replace(/\\/g, '/').startsWith(dirPrefix));
-            containedExpandedOutputs = expandedOutputs.filter((o) => o.replace(/\\/g, '/').startsWith(dirPrefix));
-        }
-    }
-    return {
-        value: rawFileToCheck,
-        file: fileToCheck,
-        project: outputsData.project,
-        target: outputsData.target,
-        matchedOutput,
-        containedOutputPaths,
-        containedExpandedOutputs,
-    };
 }
 // ── Render ──────────────────────────────────────────────────────────
-function renderOutputs(data, args) {
+function renderOutputs(project, target, { resolved, expanded, unresolved }, args) {
     if (args.json) {
-        const jsonData = data;
-        const result = {};
-        for (const [k, v] of Object.entries(jsonData)) {
-            if (Array.isArray(v) && v.length === 0)
-                continue;
-            result[k] = v;
-        }
-        console.log(JSON.stringify(result, null, 2));
+        (0, utils_2.printJson)({
+            project,
+            target,
+            outputPaths: resolved,
+            expandedOutputs: expanded,
+            unresolvedOutputs: unresolved,
+        });
         return;
     }
     const c = (0, utils_2.pc)();
-    console.log(`${c.bold('Output paths for')} ${c.cyan(data.project)}:${c.green(data.target)}`);
-    if (data.outputPaths.length > 0) {
-        (0, utils_2.printList)('Configured outputs', data.outputPaths);
-    }
-    if (data.expandedOutputs.length > 0) {
-        (0, utils_2.printList)('Resolved outputs', data.expandedOutputs);
-    }
-    if (data.unresolvedOutputs.length > 0) {
-        (0, utils_2.printList)(`${c.yellow('Unresolved outputs')} (option not set)`, data.unresolvedOutputs);
-    }
-    if (data.outputPaths.length === 0 && data.unresolvedOutputs.length === 0) {
+    console.log(`${c.bold('Output paths for')} ${c.cyan(project)}:${c.green(target)}`);
+    (0, utils_2.printList)('Configured outputs', resolved);
+    (0, utils_2.printList)('Resolved outputs', expanded);
+    (0, utils_2.printList)(`${c.yellow('Unresolved outputs')} (option not set)`, unresolved);
+    if (resolved.length === 0 && unresolved.length === 0) {
         console.log(`\n  No outputs configured for this target.`);
     }
 }
-function renderCheckOutput(data) {
-    const c = (0, utils_2.pc)();
-    const displayPath = data.value || data.file;
-    if (data.matchedOutput) {
-        console.log(`${c.green('✓')} ${c.bold(displayPath)} is an output of ${c.cyan(data.project)}:${c.green(data.target)}`);
-    }
-    else if (data.containedOutputPaths.length > 0 ||
-        data.containedExpandedOutputs.length > 0) {
-        const uniquePaths = new Set([
-            ...data.containedOutputPaths,
-            ...data.containedExpandedOutputs,
-        ]);
-        console.log(`${c.yellow('~')} ${c.bold(displayPath)} is a directory containing ${c.bold(String(uniquePaths.size))} output path(s) for ${c.cyan(data.project)}:${c.green(data.target)}`);
-        const extraExpanded = data.containedExpandedOutputs.filter((o) => !data.containedOutputPaths.includes(o));
-        if (extraExpanded.length > 0) {
-            (0, utils_2.printList)('Expanded outputs', extraExpanded);
-        }
-    }
-    else {
-        console.log(`${c.red('✗')} ${c.bold(displayPath)} is ${c.red('not')} an output of ${c.cyan(data.project)}:${c.green(data.target)}`);
-    }
-}
-function renderBatchCheckOutputs(results, projectName, targetName) {
-    const c = (0, utils_2.pc)();
-    const label = `${c.cyan(projectName)}:${c.green(targetName)}`;
-    const matched = [];
-    const directories = [];
-    const unmatched = [];
-    for (const r of results) {
-        if (r.matchedOutput) {
-            matched.push(r.value);
-        }
-        else {
-            const uniqueCount = new Set([
-                ...r.containedOutputPaths,
-                ...r.containedExpandedOutputs,
-            ]).size;
-            if (uniqueCount > 0) {
-                directories.push({ value: r.file, count: uniqueCount });
-            }
-            else {
-                unmatched.push(r.value);
-            }
-        }
-    }
-    if (matched.length > 0 || directories.length > 0) {
-        console.log(`\n${c.green('✓')} These arguments were outputs of ${label}:`);
-        for (const v of matched)
-            console.log(`  ${v}`);
-        for (const d of directories) {
-            console.log(`  ${d.value} (directory containing ${d.count} output paths)`);
-        }
-    }
-    if (unmatched.length > 0) {
-        console.log(`\n${c.red('✗')} These arguments were ${c.red('not')} outputs of ${label}:`);
-        for (const v of unmatched)
-            console.log(`  ${v}`);
-    }
-}

package/dist/src/command-line/show/show-target/utils.d.ts

@@ -24,3 +24,31 @@ export declare function normalizePath(p: string): string;
 export declare function deduplicateFolderEntries(items: string[]): string[];
 export declare function pc(): any;
 export declare function printList(header: string, items: unknown[], prefix?: string): void;
+export declare function printJson(data: Record<string, unknown>): void;
+/** The paths that live under `dir`. An empty `dir` is the workspace root. */
+export declare function pathsUnder(dir: string, paths: string[]): string[];
+export interface CheckResult {
+    /** The argument as the user typed it. */
+    value: string;
+    /** Workspace-relative form of `value`. */
+    file: string;
+    matched: boolean;
+    /** Which rule matched, when the caller can name one. */
+    category?: string;
+    /** Matches found underneath `value`, when it is a directory. */
+    contained: string[];
+}
+declare const NOUNS: {
+    readonly input: {
+        readonly preposition: 'for';
+        readonly contained: 'input file';
+    };
+    readonly output: {
+        readonly preposition: 'of';
+        readonly contained: 'output path';
+    };
+};
+type CheckNoun = keyof typeof NOUNS;
+export declare function renderCheckResults(results: CheckResult[], project: string, target: string, noun: CheckNoun): void;
+export declare function setCheckExitCode(results: CheckResult[]): void;
+export {};