nx 23.2.0-beta.0 → 23.2.0-beta.2

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 {};

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

@@ -6,6 +6,10 @@ exports.normalizePath = normalizePath;
 exports.deduplicateFolderEntries = deduplicateFolderEntries;
 exports.pc = pc;
 exports.printList = printList;
+exports.printJson = printJson;
+exports.pathsUnder = pathsUnder;
+exports.renderCheckResults = renderCheckResults;
+exports.setCheckExitCode = setCheckExitCode;
 const path_1 = require("path");
 const calculate_default_project_name_1 = require("../../../config/calculate-default-project-name");
 const configuration_1 = require("../../../config/configuration");
@@ -29,18 +33,22 @@ async function resolveTarget(args, opts) {
     }
     const nxJson = (0, configuration_1.readNxJson)();
     const { projectName, targetName, configurationName } = resolveTargetIdentifier(args, graph, nxJson);
+    // `resolveProjectNode` accepts a pattern specifier (`my-*`), so the concrete
+    // name it resolved to is the one everything downstream has to use — it is a
+    // lookup key for the task id, not just a label.
     const node = resolveProjectNode(projectName, graph);
+    const resolvedProjectName = node.name;
     if (!node.data.targets?.[targetName]) {
-        reportTargetNotFound(projectName, targetName, node);
+        reportTargetNotFound(resolvedProjectName, targetName, node);
     }
     const configuration = configurationName ?? args.configuration;
     if (configuration) {
-        validateConfiguration(projectName, targetName, configuration, node.data.targets[targetName]);
+        validateConfiguration(resolvedProjectName, targetName, configuration, node.data.targets[targetName]);
     }
     return {
         graph,
         nxJson,
-        projectName,
+        projectName: resolvedProjectName,
         targetName,
         configuration,
         node,
@@ -183,3 +191,75 @@ function printList(header, items, prefix = '\n') {
     for (const item of items)
         console.log(`  ${item}`);
 }
+function printJson(data) {
+    const result = {};
+    for (const [key, value] of Object.entries(data)) {
+        if (Array.isArray(value) && value.length === 0)
+            continue;
+        result[key] = value;
+    }
+    console.log(JSON.stringify(result, null, 2));
+}
+/** The paths that live under `dir`. An empty `dir` is the workspace root. */
+function pathsUnder(dir, paths) {
+    if (dir === '')
+        return [...paths];
+    const prefix = dir.endsWith('/') ? dir : dir + '/';
+    return paths.filter((p) => p.startsWith(prefix));
+}
+const NOUNS = {
+    input: { preposition: 'for', contained: 'input file' },
+    output: { preposition: 'of', contained: 'output path' },
+};
+function renderCheckResults(results, project, target, noun) {
+    if (results.length >= 2) {
+        renderBatchCheckResults(results, project, target, noun);
+        return;
+    }
+    for (const result of results) {
+        renderCheckResult(result, project, target, noun);
+    }
+}
+function setCheckExitCode(results) {
+    for (const result of results) {
+        process.exitCode ||= result.matched || result.contained.length ? 0 : 1;
+    }
+}
+function renderCheckResult(result, project, target, noun) {
+    const c = pc();
+    const { preposition, contained } = NOUNS[noun];
+    const label = `${c.cyan(project)}:${c.green(target)}`;
+    if (result.matched) {
+        const category = result.category ? ` (${result.category})` : '';
+        console.log(`${c.green('✓')} ${c.bold(result.value)} is an ${noun} ${preposition} ${label}${category}`);
+    }
+    else if (result.contained.length > 0) {
+        console.log(`${c.yellow('~')} ${c.bold(result.file)} is a directory containing ${c.bold(String(result.contained.length))} ${contained}(s) ${preposition} ${label}`);
+        for (const item of [...result.contained].sort())
+            console.log(`  ${item}`);
+    }
+    else {
+        console.log(`${c.red('✗')} ${c.bold(result.value)} is ${c.red('not')} an ${noun} ${preposition} ${label}`);
+    }
+}
+function renderBatchCheckResults(results, project, target, noun) {
+    const c = pc();
+    const { preposition, contained } = NOUNS[noun];
+    const label = `${c.cyan(project)}:${c.green(target)}`;
+    const matched = results.filter((r) => r.matched);
+    const directories = results.filter((r) => !r.matched && r.contained.length);
+    const unmatched = results.filter((r) => !r.matched && !r.contained.length);
+    if (matched.length > 0 || directories.length > 0) {
+        console.log(`\n${c.green('✓')} These arguments were ${noun}s ${preposition} ${label}:`);
+        for (const r of matched)
+            console.log(`  ${r.value}`);
+        for (const r of directories) {
+            console.log(`  ${r.file} (directory containing ${r.contained.length} ${contained}s)`);
+        }
+    }
+    if (unmatched.length > 0) {
+        console.log(`\n${c.red('✗')} These arguments were ${c.red('not')} ${noun}s ${preposition} ${label}:`);
+        for (const r of unmatched)
+            console.log(`  ${r.value}`);
+    }
+}

package/dist/src/command-line/yargs-utils/shared-options.d.ts

@@ -1,4 +1,4 @@
-import { Argv, ParserConfigurationOptions } from 'yargs';
+import type { Argv, ParserConfigurationOptions } from 'yargs';
 interface ExcludeOptions {
     exclude: string[];
 }

package/dist/src/commands-runner/create-command-graph.js

@@ -41,6 +41,11 @@ function createCommandGraph(projectGraph, projectNames, nxArgs) {
             recursiveResolveDeps(projectGraph, projectName, dependencies);
         }
     }
+    else {
+        for (const projectName of projectNames) {
+            dependencies[projectName] = [];
+        }
+    }
     const roots = Object.keys(dependencies).filter((d) => dependencies[d].length === 0);
     const commandGraph = {
         dependencies,

package/dist/src/config/nx-json.d.ts

@@ -787,7 +787,7 @@ export interface NxJsonConfiguration<T = '*' | string[]> {
     targetDefaults?: TargetDefaults;
     /**
      * Default options for `nx affected`
-     * @deprecated use {@link defaultBase} instead. For more information see https://nx.dev/deprecated/affected-config#affected-config
+     * @deprecated use {@link defaultBase} instead. For more information see https://nx.dev/docs/reference/nx-json#default-base
      */
     affected?: NxAffectedConfig;
     /**