nx 23.2.0-beta.1 → 23.2.0-beta.3

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/config/nx-json.d.ts

@@ -54,8 +54,10 @@ export type TargetDefaultEntry = {
 export type TargetDefaultFilter = {
     /**
      * Restrict the default to targets originated by a specific plugin
-     * (e.g. `@nx/vite`). Matches against the plugin that wrote the target's
-     * `executor` or `command`.
+     * (e.g. `@nx/vite`). Matches against the plugin from nx.json's `plugins`
+     * that wrote the target's `executor` or `command`. Targets whose
+     * executor/command comes from `project.json` or `package.json` have no
+     * source plugin and never match.
      */
     plugin?: string;
     /**