@ohos-ports/nx 23.2.0-beta.0 → 23.2.1-beta.0

package/dist/src/command-line/show/project.js

@@ -1,103 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.showProjectHandler = showProjectHandler;
-const output_1 = require("../../utils/output");
-const project_graph_1 = require("../../project-graph/project-graph");
-const graph_1 = require("../graph/graph");
-const find_matching_projects_1 = require("../../utils/find-matching-projects");
-const workspace_root_1 = require("../../utils/workspace-root");
-const configuration_1 = require("../../config/configuration");
-const calculate_default_project_name_1 = require("../../config/calculate-default-project-name");
-async function showProjectHandler(args) {
-    performance.mark('code-loading:end');
-    performance.measure('code-loading', 'init-local', 'code-loading:end');
-    const graph = await (0, project_graph_1.createProjectGraphAsync)();
-    let projectName = args.projectName;
-    // If no project name is provided, try to infer from cwd
-    if (!projectName) {
-        const nxJson = (0, configuration_1.readNxJson)();
-        projectName = (0, calculate_default_project_name_1.calculateDefaultProjectName)(process.cwd(), workspace_root_1.workspaceRoot, (0, project_graph_1.readProjectsConfigurationFromProjectGraph)(graph), nxJson);
-        if (!projectName) {
-            output_1.output.error({
-                title: 'Could not find a project in the current working directory.',
-                bodyLines: [
-                    `Please specify a project name using:`,
-                    `  nx show project <project-name>`,
-                    ``,
-                    `Or run this command from within a project directory.`,
-                ],
-            });
-            process.exit(1);
-        }
-    }
-    let node = graph.nodes[projectName];
-    if (!node) {
-        const projects = (0, find_matching_projects_1.findMatchingProjects)([projectName], graph.nodes);
-        if (projects.length === 1) {
-            const matchedProjectName = projects[0];
-            node = graph.nodes[matchedProjectName];
-        }
-        else if (projects.length > 1) {
-            output_1.output.error({
-                title: `Multiple projects matched:`,
-                bodyLines: projects.length > 100 ? [...projects.slice(0, 100), '...'] : projects,
-            });
-            console.log(`Multiple projects matched:\n  ${(projects.length > 100
-                ? [...projects.slice(0, 100), '...']
-                : projects).join('  \n')}`);
-            process.exit(1);
-        }
-        else {
-            console.log(`Could not find project ${projectName}`);
-            process.exit(1);
-        }
-    }
-    if (args.json) {
-        console.log(JSON.stringify(node.data));
-    }
-    else if (args.web) {
-        await (0, graph_1.generateGraph)({
-            view: 'project-details',
-            focus: node.name,
-            watch: true,
-            open: args.open ?? true,
-        }, []);
-    }
-    else {
-        const pc = require('picocolors');
-        const logIfExists = (label, key) => {
-            if (node.data[key]) {
-                console.log(`${pc.bold(label)}: ${node.data[key]}`);
-            }
-        };
-        logIfExists('Name', 'name');
-        logIfExists('Root', 'root');
-        logIfExists('Source Root', 'sourceRoot');
-        logIfExists('Tags', 'tags');
-        logIfExists('Implicit Dependencies', 'implicitDependencies');
-        const targets = Object.entries(node.data.targets ?? {});
-        const maxTargetNameLength = Math.max(...targets.map(([t]) => t.length));
-        const maxExecutorNameLength = Math.max(...targets.map(([, t]) => t?.executor?.length ?? 0));
-        if (targets.length > 0) {
-            console.log(`${pc.bold('Targets')}: `);
-            for (const [target, targetConfig] of targets) {
-                const executorCommandText = targetConfig.metadata?.scriptContent ??
-                    targetConfig?.options?.command ??
-                    (targetConfig?.options?.commands?.length === 1
-                        ? targetConfig.options.commands[0]
-                        : targetConfig?.executor) ??
-                    '';
-                console.log(`- ${pc.bold((target + ':').padEnd(maxTargetNameLength + 2))} ${executorCommandText.padEnd(maxExecutorNameLength + 2)} ${(() => {
-                    const configurations = Object.keys(targetConfig.configurations ?? {});
-                    if (configurations.length) {
-                        return pc.dim(configurations.join(', '));
-                    }
-                    return '';
-                })()}`);
-            }
-        }
-    }
-    // TODO: Find a better fix for this
-    await new Promise((res) => setImmediate(res));
-    await output_1.output.drain();
-}

package/dist/src/command-line/show/projects.d.ts

@@ -1,2 +0,0 @@
-import { ShowProjectsOptions } from './command-object';
-export declare function showProjectsHandler(args: ShowProjectsOptions): Promise<void>;

package/dist/src/command-line/show/projects.js

@@ -1,80 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.showProjectsHandler = showProjectsHandler;
-const output_1 = require("../../utils/output");
-const nx_json_1 = require("../../config/nx-json");
-const affected_project_graph_1 = require("../../project-graph/affected/affected-project-graph");
-const file_utils_1 = require("../../project-graph/file-utils");
-const operators_1 = require("../../project-graph/operators");
-const project_graph_1 = require("../../project-graph/project-graph");
-const command_line_utils_1 = require("../../utils/command-line-utils");
-const find_matching_projects_1 = require("../../utils/find-matching-projects");
-async function showProjectsHandler(args) {
-    performance.mark('code-loading:end');
-    performance.measure('code-loading', 'init-local', 'code-loading:end');
-    let graph = await (0, project_graph_1.createProjectGraphAsync)();
-    const nxJson = (0, nx_json_1.readNxJson)();
-    const { nxArgs } = (0, command_line_utils_1.splitArgsIntoNxArgsAndOverrides)(args, 'affected', {
-        printWarnings: false,
-    }, nxJson);
-    // Affected touches dependencies so it needs to be processed first.
-    if (args.affected) {
-        const touchedFiles = await getTouchedFiles(nxArgs);
-        graph = await getAffectedGraph(touchedFiles, nxJson, graph);
-    }
-    const filter = (0, operators_1.filterNodes)((node) => {
-        if (args.type && node.type !== args.type) {
-            return false;
-        }
-        return true;
-    });
-    graph = filter(graph);
-    // Apply projects filter and get resultant graph
-    if (args.projects) {
-        graph.nodes = getGraphNodesMatchingPatterns(graph, args.projects);
-    }
-    // Grab only the nodes with the specified target
-    if (args.withTarget) {
-        graph.nodes = Object.entries(graph.nodes).reduce((acc, [name, node]) => {
-            if (args.withTarget.some((target) => node.data.targets?.[target])) {
-                acc[name] = node;
-            }
-            return acc;
-        }, {});
-    }
-    const selectedProjects = new Set(Object.keys(graph.nodes));
-    if (args.exclude) {
-        const excludedProjects = (0, find_matching_projects_1.findMatchingProjects)(nxArgs.exclude, graph.nodes);
-        for (const excludedProject of excludedProjects) {
-            selectedProjects.delete(excludedProject);
-        }
-    }
-    if (args.json) {
-        console.log(JSON.stringify(Array.from(selectedProjects)));
-    }
-    else if (args.sep) {
-        console.log(Array.from(selectedProjects.values()).join(args.sep));
-    }
-    else {
-        for (const project of selectedProjects) {
-            console.log(project);
-        }
-    }
-    // TODO: Find a better fix for this
-    await new Promise((res) => setImmediate(res));
-    await output_1.output.drain();
-}
-function getGraphNodesMatchingPatterns(graph, patterns) {
-    const nodes = {};
-    const matches = (0, find_matching_projects_1.findMatchingProjects)(patterns, graph.nodes);
-    for (const match of matches) {
-        nodes[match] = graph.nodes[match];
-    }
-    return nodes;
-}
-function getAffectedGraph(touchedFiles, nxJson, graph) {
-    return (0, affected_project_graph_1.filterAffected)(graph, touchedFiles, nxJson);
-}
-async function getTouchedFiles(nxArgs) {
-    return (0, file_utils_1.calculateFileChanges)((0, command_line_utils_1.parseFiles)(nxArgs).files, nxArgs);
-}

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

@@ -1,3 +0,0 @@
-export { showTargetInfoHandler } from './info';
-export { showTargetInputsHandler } from './inputs';
-export { showTargetOutputsHandler } from './outputs';

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

@@ -1,9 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.showTargetOutputsHandler = exports.showTargetInputsHandler = exports.showTargetInfoHandler = void 0;
-var info_1 = require("./info");
-Object.defineProperty(exports, "showTargetInfoHandler", { enumerable: true, get: function () { return info_1.showTargetInfoHandler; } });
-var inputs_1 = require("./inputs");
-Object.defineProperty(exports, "showTargetInputsHandler", { enumerable: true, get: function () { return inputs_1.showTargetInputsHandler; } });
-var outputs_1 = require("./outputs");
-Object.defineProperty(exports, "showTargetOutputsHandler", { enumerable: true, get: function () { return outputs_1.showTargetOutputsHandler; } });

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

@@ -1,28 +0,0 @@
-import type { InputDefinition } from '../../../config/workspace-json-project-json';
-import type { ShowTargetBaseOptions } from '../command-object';
-import { type ResolvedTarget } from './utils';
-export declare function showTargetInfoHandler(args: ShowTargetBaseOptions): Promise<void>;
-export type TargetInfoData = ReturnType<typeof resolveTargetInfoData>;
-declare function resolveTargetInfoData(t: ResolvedTarget): {
-    project: string;
-    target: string;
-    configuration?: string;
-    executor: string;
-    command?: string;
-    _commandSourceKey?: string;
-    customHasher?: boolean;
-    dependsOn?: string[];
-    _depSources?: number[];
-    transitiveTasks?: string[];
-    parallelism: boolean;
-    continuous: boolean;
-    cache: boolean;
-    inputs?: (string | InputDefinition)[];
-    _inputSources?: number[];
-    outputs?: string[];
-    options: any;
-    configurations?: string[];
-    defaultConfiguration?: string;
-    sourceMap?: Record<string, [file: string, plugin: string]>;
-};
-export {};

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

@@ -1,389 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.showTargetInfoHandler = showTargetInfoHandler;
-const task_hasher_1 = require("../../../hasher/task-hasher");
-const create_task_graph_1 = require("../../../tasks-runner/create-task-graph");
-const utils_1 = require("../../../tasks-runner/utils");
-const utils_2 = require("./utils");
-// ── Handler ─────────────────────────────────────────────────────────
-async function showTargetInfoHandler(args) {
-    const t = await (0, utils_2.resolveTarget)(args, { withSourceMaps: true });
-    const data = resolveTargetInfoData(t);
-    renderTargetInfo(data, args);
-}
-function resolveTargetInfoData(t) {
-    const { projectName, targetName, configuration, node, graph, nxJson, sourceMaps, } = t;
-    const targetConfig = node.data.targets[targetName];
-    const allTargetNames = new Set();
-    for (const n of Object.values(graph.nodes)) {
-        for (const name of Object.keys(n.data.targets ?? {})) {
-            allTargetNames.add(name);
-        }
-    }
-    const depConfigs = (0, utils_1.getDependencyConfigs)({ project: projectName, target: targetName }, 
-    // no programmatic extras — `dependsOn` is already merged into the graph node
-    {}, graph, [...allTargetNames]) ?? [];
-    // Determine the hoisted command value and which option key it came from
-    let command;
-    let commandSourceKey;
-    if (targetConfig.metadata?.scriptContent) {
-        command = targetConfig.metadata.scriptContent;
-        commandSourceKey = 'options.script';
-    }
-    else if (targetConfig.options?.command) {
-        command = targetConfig.options.command;
-        commandSourceKey = 'options.command';
-    }
-    else if (targetConfig.options?.commands?.length === 1) {
-        command = targetConfig.options.commands[0];
-        commandSourceKey = 'options.commands';
-    }
-    else if (targetConfig.executor === 'nx:run-script' &&
-        targetConfig.options?.script) {
-        command = targetConfig.options.script;
-        commandSourceKey = 'options.script';
-    }
-    const { dependsOn, depSourceIndices, transitiveTasks } = resolveTaskGraphDependencies(graph, {}, projectName, targetName, configuration, depConfigs);
-    const configurations = Object.keys(targetConfig.configurations ?? {});
-    const targetSourceMap = extractTargetSourceMap(node.data.root, targetName, sourceMaps);
-    const usesCustomHasher = (0, utils_2.hasCustomHasher)(projectName, targetName, graph);
-    return {
-        project: projectName,
-        target: targetName,
-        ...(configuration ? { configuration } : {}),
-        executor: targetConfig.executor,
-        ...(command ? { command, _commandSourceKey: commandSourceKey } : {}),
-        ...(usesCustomHasher ? { customHasher: true } : {}),
-        ...(dependsOn.length > 0
-            ? { dependsOn, _depSources: depSourceIndices }
-            : {}),
-        ...(transitiveTasks.length > 0 ? { transitiveTasks } : {}),
-        parallelism: targetConfig.parallelism ?? true,
-        continuous: targetConfig.continuous ?? false,
-        cache: targetConfig.cache ?? false,
-        ...(targetConfig.inputs
-            ? (() => {
-                const expanded = expandInputsForDisplay(targetConfig.inputs, node, nxJson);
-                return {
-                    inputs: expanded.map((e) => e.value),
-                    _inputSources: expanded.map((e) => e.originalIndex),
-                };
-            })()
-            : {}),
-        ...(targetConfig.outputs
-            ? { outputs: targetConfig.outputs }
-            : {}),
-        options: {
-            ...targetConfig.options,
-            ...(configuration
-                ? targetConfig.configurations?.[configuration]
-                : undefined),
-        },
-        ...(configurations.length > 0 ? { configurations } : {}),
-        ...(targetConfig.defaultConfiguration
-            ? { defaultConfiguration: targetConfig.defaultConfiguration }
-            : {}),
-        ...(targetSourceMap ? { sourceMap: targetSourceMap } : {}),
-    };
-}
-function resolveDependencyProjects(dep, projectName, graph) {
-    if (dep.projects && dep.projects.length > 0)
-        return dep.projects;
-    if (dep.dependencies) {
-        const depEdges = graph.dependencies[projectName] ?? [];
-        return depEdges
-            .filter((edge) => {
-            const depNode = graph.nodes[edge.target];
-            return depNode && depNode.data.targets?.[dep.target];
-        })
-            .map((edge) => edge.target);
-    }
-    return [projectName];
-}
-/**
- * Builds a task graph rooted at the requested target and returns:
- *   - `dependsOn`: direct task dependencies of the root, with real
- *     project/target resolution applied.
- *   - `depSourceIndices`: for each direct dep, the index of the original
- *     depConfig it corresponds to (for source-map hints), or -1 if unknown.
- *   - `transitiveTasks`: task IDs reachable through the direct deps (not
- *     the root, not direct deps).
- *
- * If `createTaskGraph` throws (e.g. circular dependencies), falls back to
- * the `depConfig`-based resolution so the output still shows the configured
- * list rather than silently collapsing to empty.
- */
-function resolveTaskGraphDependencies(graph, extraTargetDeps, projectName, targetName, configuration, depConfigs) {
-    try {
-        const taskGraph = (0, create_task_graph_1.createTaskGraph)(graph, extraTargetDeps, [projectName], [targetName], configuration, {});
-        // `createTaskGraph` resolves the target's `defaultConfiguration`, so the real
-        // root task id may carry a `:config` suffix that `createTaskId` with the raw
-        // configuration would omit. Find the root task by (project, target) instead.
-        const rootTask = Object.values(taskGraph.tasks).find((task) => task.target.project === projectName && task.target.target === targetName);
-        const rootId = rootTask?.id ?? (0, utils_1.createTaskId)(projectName, targetName, configuration);
-        // Continuous dependencies (e.g. dev servers) live in a separate map but are
-        // direct dependencies just like the entries in `dependencies`.
-        const directDeps = [
-            ...(taskGraph.dependencies[rootId] ?? []),
-            ...(taskGraph.continuousDependencies[rootId] ?? []),
-        ];
-        const directDepSet = new Set(directDeps);
-        const depSourceIndices = directDeps.map((depTaskId) => {
-            const task = taskGraph.tasks[depTaskId];
-            if (!task)
-                return -1;
-            return findDepConfigIndex(task.target, depConfigs, projectName, graph);
-        });
-        // `Object.keys(dependencies)` gives the set of real (non-dummy) tasks
-        // in the graph — `filterDummyTasks` (called inside `createTaskGraph`)
-        // removes dummy entries from `dependencies` but leaves them in `tasks`.
-        const transitiveTasks = Object.keys(taskGraph.dependencies).filter((id) => id !== rootId && !directDepSet.has(id));
-        return { dependsOn: directDeps, depSourceIndices, transitiveTasks };
-    }
-    catch {
-        return {
-            ...resolveDependsOnFromConfigs(depConfigs, projectName, graph),
-            transitiveTasks: [],
-        };
-    }
-}
-function resolveDependsOnFromConfigs(depConfigs, projectName, graph) {
-    const dependsOn = [];
-    const depSourceIndices = [];
-    for (let i = 0; i < depConfigs.length; i++) {
-        const dep = depConfigs[i];
-        const projects = resolveDependencyProjects(dep, projectName, graph);
-        for (const p of projects) {
-            dependsOn.push(`${p}:${dep.target}`);
-            depSourceIndices.push(i);
-        }
-    }
-    return { dependsOn, depSourceIndices };
-}
-/**
- * Builds the summary line shown beneath the direct `Depends On` list.
- *
- * Up to 3 unique target names: list them (`and 5 build, compile transitive tasks`).
- * Beyond that: collapse to the count alone (`and 12 transitive tasks`).
- */
-function formatTransitiveSummary(taskIds) {
-    const count = taskIds.length;
-    const plural = count === 1 ? 'task' : 'tasks';
-    const targetNames = uniqueTargetNames(taskIds);
-    if (targetNames.length === 0 || targetNames.length > 3) {
-        return `and ${count} transitive ${plural}`;
-    }
-    return `and ${count} ${targetNames.join(', ')} transitive ${plural}`;
-}
-function uniqueTargetNames(taskIds) {
-    const set = new Set();
-    for (const id of taskIds) {
-        // task ids are `project:target` or `project:target:config`
-        const parts = id.split(':');
-        if (parts.length >= 2)
-            set.add(parts[1]);
-    }
-    return [...set].sort();
-}
-function findDepConfigIndex(taskTarget, depConfigs, rootProject, graph) {
-    for (let i = 0; i < depConfigs.length; i++) {
-        const dep = depConfigs[i];
-        if (dep.target !== taskTarget.target)
-            continue;
-        const resolved = resolveDependencyProjects(dep, rootProject, graph);
-        if (resolved.includes(taskTarget.project))
-            return i;
-    }
-    return -1;
-}
-/**
- * Expands named inputs (e.g. "production") to their definitions while
- * tracking which original input index each expanded item came from.
- * This lets the renderer look up `inputs.${originalIndex}` in the source map.
- */
-function expandInputsForDisplay(inputs, node, nxJson) {
-    const namedInputs = (0, task_hasher_1.getNamedInputs)(nxJson, node);
-    const result = [];
-    for (let i = 0; i < inputs.length; i++) {
-        const input = inputs[i];
-        if (typeof input === 'string') {
-            if (input.startsWith('^')) {
-                result.push({ value: input, originalIndex: i });
-            }
-            else if (namedInputs[input]) {
-                for (const expanded of namedInputs[input]) {
-                    result.push({ value: expanded, originalIndex: i });
-                }
-            }
-            else {
-                result.push({ value: input, originalIndex: i });
-            }
-        }
-        else if ('input' in input) {
-            const name = input.input;
-            // Don't expand when the input has additional qualifiers (e.g. projects)
-            // since those scopes are meaningful and would be lost by expansion
-            const hasQualifiers = Object.keys(input).length > 1;
-            if (!hasQualifiers && !name.startsWith('^') && namedInputs[name]) {
-                for (const expanded of namedInputs[name]) {
-                    result.push({ value: expanded, originalIndex: i });
-                }
-            }
-            else {
-                result.push({ value: input, originalIndex: i });
-            }
-        }
-        else {
-            result.push({ value: input, originalIndex: i });
-        }
-    }
-    return result;
-}
-function extractTargetSourceMap(projectRoot, targetName, sourceMaps) {
-    if (!sourceMaps)
-        return undefined;
-    const projectSourceMap = sourceMaps[projectRoot];
-    if (!projectSourceMap)
-        return undefined;
-    const prefix = `targets.${targetName}.`;
-    const targetEntry = `targets.${targetName}`;
-    const result = {};
-    for (const [key, value] of Object.entries(projectSourceMap)) {
-        if (key === targetEntry) {
-            result['target'] = value;
-        }
-        else if (key.startsWith(prefix)) {
-            result[key.slice(prefix.length)] = value;
-        }
-    }
-    return Object.keys(result).length > 0 ? result : undefined;
-}
-// ── Render ──────────────────────────────────────────────────────────
-function renderTargetInfo(data, args) {
-    if (args.json) {
-        // Strip internal renderer-only fields from JSON output
-        const { _inputSources, _depSources, _commandSourceKey, ...jsonData } = data;
-        console.log(JSON.stringify(jsonData, null, 2));
-        return;
-    }
-    const c = (0, utils_2.pc)();
-    const sm = data.sourceMap;
-    const sourceHint = (key, fallbackKey) => {
-        if (!args.verbose)
-            return '';
-        const entry = sm?.[key] ?? (fallbackKey ? sm?.[fallbackKey] : undefined);
-        if (!entry)
-            return '';
-        const [file, plugin] = entry;
-        if (file && plugin)
-            return ` ${c.dim(`(from ${file} by ${plugin})`)}`;
-        if (file)
-            return ` ${c.dim(`(from ${file})`)}`;
-        if (plugin)
-            return ` ${c.dim(`(by ${plugin})`)}`;
-        return '';
-    };
-    console.log(`${c.bold('Target')}: ${c.cyan(data.project)}:${c.green(data.target)}${sourceHint('target')}`);
-    if (data.command) {
-        const label = data.executor === 'nx:run-script' ? 'Script' : 'Command';
-        const cmdHint = data._commandSourceKey
-            ? sourceHint(data._commandSourceKey)
-            : '';
-        console.log(`${c.bold(label)}: ${data.command}${cmdHint}`);
-    }
-    else if (data.executor) {
-        console.log(`${c.bold('Executor')}: ${data.executor}${sourceHint('executor')}`);
-    }
-    if (data.customHasher) {
-        console.log(`${c.bold('Hasher')}: ${c.yellow('custom')} ${c.dim('(inputs do not affect cache hash)')}`);
-    }
-    if (data.configuration)
-        console.log(`${c.bold('Configuration')}: ${data.configuration}`);
-    if (data.dependsOn && data.dependsOn.length > 0) {
-        console.log(`${c.bold('Depends On')}:`);
-        for (let i = 0; i < data.dependsOn.length; i++) {
-            const srcIdx = data._depSources?.[i];
-            const hint = srcIdx !== undefined && srcIdx >= 0
-                ? sourceHint(`dependsOn.${srcIdx}`, 'dependsOn')
-                : sourceHint('dependsOn');
-            console.log(`  ${data.dependsOn[i]}${hint}`);
-        }
-        if (data.transitiveTasks && data.transitiveTasks.length > 0) {
-            console.log(`  ${c.dim(formatTransitiveSummary(data.transitiveTasks))}`);
-        }
-    }
-    console.log(`${c.bold('Parallelism')}: ${data.parallelism}${sourceHint('parallelism')}`);
-    console.log(`${c.bold('Continuous')}: ${data.continuous}${sourceHint('continuous')}`);
-    console.log(`${c.bold('Cache')}: ${data.cache}${sourceHint('cache')}`);
-    if (data.inputs && data.inputs.length > 0) {
-        console.log(`${c.bold('Inputs')}:`);
-        const inputSources = data._inputSources;
-        // Build sortable entries with their source index
-        const entries = data.inputs.map((input, i) => ({
-            value: input,
-            sourceIndex: inputSources?.[i],
-        }));
-        entries.sort((a, b) => {
-            const aIsString = typeof a.value === 'string';
-            const bIsString = typeof b.value === 'string';
-            if (!aIsString && bIsString)
-                return 1;
-            if (aIsString && !bIsString)
-                return -1;
-            if (aIsString && bIsString) {
-                const aStr = a.value;
-                const bStr = b.value;
-                const aIsDep = aStr.startsWith('^');
-                const bIsDep = bStr.startsWith('^');
-                if (aIsDep && !bIsDep)
-                    return 1;
-                if (!aIsDep && bIsDep)
-                    return -1;
-                return aStr < bStr ? -1 : aStr > bStr ? 1 : 0;
-            }
-            return 0;
-        });
-        for (const { value, sourceIndex } of entries) {
-            const display = typeof value === 'string' ? value : JSON.stringify(value);
-            const hint = sourceIndex !== undefined
-                ? sourceHint(`inputs.${sourceIndex}`, 'inputs')
-                : '';
-            console.log(`  - ${display}${hint}`);
-        }
-    }
-    if (data.outputs && data.outputs.length > 0) {
-        console.log(`${c.bold('Outputs')}:`);
-        for (let i = 0; i < data.outputs.length; i++) {
-            const hint = sourceHint(`outputs.${i}`, 'outputs');
-            console.log(`  - ${data.outputs[i]}${hint}`);
-        }
-    }
-    // When command is hoisted, hide the corresponding option key from display
-    const hoistedOptionKey = data._commandSourceKey?.startsWith('options.')
-        ? data._commandSourceKey.slice('options.'.length)
-        : undefined;
-    const displayOptions = Object.entries(data.options).filter(([key]) => key !== hoistedOptionKey);
-    if (displayOptions.length > 0) {
-        console.log(`${c.bold('Options')}:`);
-        for (const [key, value] of displayOptions) {
-            const hint = sourceHint(`options.${key}`);
-            if (typeof value === 'object' && value !== null) {
-                console.log(`  ${key}:${hint}`);
-                const lines = JSON.stringify(value, null, 2).split('\n');
-                for (const line of lines) {
-                    console.log(`    ${line}`);
-                }
-            }
-            else {
-                console.log(`  ${key}: ${JSON.stringify(value)}${hint}`);
-            }
-        }
-    }
-    if (data.configurations && data.configurations.length > 0) {
-        const configList = data.configurations
-            .map((cfg) => cfg === data.defaultConfiguration ? `${cfg} ${c.dim('(default)')}` : cfg)
-            .join(', ');
-        console.log(`${c.bold('Configurations')}: ${configList}`);
-    }
-    console.log('');
-}

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

@@ -1,2 +0,0 @@
-import type { ShowTargetInputsOptions } from '../command-object';
-export declare function showTargetInputsHandler(args: ShowTargetInputsOptions): Promise<void>;