@ohos-ports/nx 17.3.2-beta.0

package/src/command-line/report/report.js

@@ -0,0 +1,232 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findInstalledPackagesWeCareAbout = exports.findInstalledCommunityPlugins = exports.findMisalignedPackagesForPackage = exports.getReportData = exports.reportHandler = exports.patternsWeIgnoreInCommunityReport = exports.packagesWeCareAbout = void 0;
+const chalk = require("chalk");
+const output_1 = require("../../utils/output");
+const path_1 = require("path");
+const package_manager_1 = require("../../utils/package-manager");
+const fileutils_1 = require("../../utils/fileutils");
+const package_json_1 = require("../../utils/package-json");
+const local_plugins_1 = require("../../utils/plugins/local-plugins");
+const project_graph_1 = require("../../project-graph/project-graph");
+const semver_1 = require("semver");
+const installed_plugins_1 = require("../../utils/plugins/installed-plugins");
+const installation_directory_1 = require("../../utils/installation-directory");
+const nx_json_1 = require("../../config/nx-json");
+const nxPackageJson = (0, fileutils_1.readJsonFile)((0, path_1.join)(__dirname, '../../../package.json'));
+exports.packagesWeCareAbout = [
+    'lerna',
+    ...nxPackageJson['nx-migrations'].packageGroup.map((x) => typeof x === 'string' ? x : x.package),
+    '@nrwl/schematics', // manually added since we don't publish it anymore.
+    'typescript',
+];
+exports.patternsWeIgnoreInCommunityReport = [
+    ...exports.packagesWeCareAbout,
+    '@schematics/angular',
+    new RegExp('@angular/*'),
+    '@nestjs/schematics',
+];
+const LINE_SEPARATOR = '---------------------------------------';
+/**
+ * Reports relevant version numbers for adding to an Nx issue report
+ *
+ * @remarks
+ *
+ * Must be run within an Nx workspace
+ *
+ */
+async function reportHandler() {
+    const { pm, pmVersion, localPlugins, communityPlugins, packageVersionsWeCareAbout, outOfSyncPackageGroup, projectGraphError, } = await getReportData();
+    const bodyLines = [
+        `Node   : ${process.versions.node}`,
+        `OS     : ${process.platform}-${process.arch}`,
+        `${pm.padEnd(7)}: ${pmVersion}`,
+        ``,
+    ];
+    let padding = Math.max(...packageVersionsWeCareAbout.map((x) => x.package.length)) + 1;
+    packageVersionsWeCareAbout.forEach((p) => {
+        bodyLines.push(`${chalk.green(p.package.padEnd(padding))} : ${chalk.bold(p.version)}`);
+    });
+    if (communityPlugins.length) {
+        bodyLines.push(LINE_SEPARATOR);
+        padding = Math.max(...communityPlugins.map((x) => x.name.length)) + 1;
+        bodyLines.push('Community plugins:');
+        communityPlugins.forEach((p) => {
+            bodyLines.push(`${chalk.green(p.name.padEnd(padding))}: ${chalk.bold(p.version)}`);
+        });
+    }
+    if (localPlugins.length) {
+        bodyLines.push(LINE_SEPARATOR);
+        bodyLines.push('Local workspace plugins:');
+        for (const plugin of localPlugins) {
+            bodyLines.push(`\t ${chalk.green(plugin)}`);
+        }
+    }
+    if (outOfSyncPackageGroup) {
+        bodyLines.push(LINE_SEPARATOR);
+        bodyLines.push(`The following packages should match the installed version of ${outOfSyncPackageGroup.basePackage}`);
+        for (const pkg of outOfSyncPackageGroup.misalignedPackages) {
+            bodyLines.push(`  - ${pkg.name}@${pkg.version}`);
+        }
+        bodyLines.push('');
+        bodyLines.push(`To fix this, run \`nx migrate ${outOfSyncPackageGroup.migrateTarget}\``);
+    }
+    if (projectGraphError) {
+        bodyLines.push(LINE_SEPARATOR);
+        bodyLines.push('⚠️ Unable to construct project graph.');
+        bodyLines.push(projectGraphError.message);
+        bodyLines.push(projectGraphError.stack);
+    }
+    output_1.output.log({
+        title: 'Report complete - copy this into the issue template',
+        bodyLines,
+    });
+}
+exports.reportHandler = reportHandler;
+async function getReportData() {
+    const pm = (0, package_manager_1.detectPackageManager)();
+    const pmVersion = (0, package_manager_1.getPackageManagerVersion)(pm);
+    const localPlugins = await findLocalPlugins((0, nx_json_1.readNxJson)());
+    const communityPlugins = findInstalledCommunityPlugins();
+    let projectGraphError = null;
+    if (isNativeAvailable()) {
+        try {
+            await (0, project_graph_1.createProjectGraphAsync)();
+        }
+        catch (e) {
+            projectGraphError = e;
+        }
+    }
+    const packageVersionsWeCareAbout = findInstalledPackagesWeCareAbout();
+    packageVersionsWeCareAbout.unshift({
+        package: 'nx',
+        version: nxPackageJson.version,
+    });
+    if (globalThis.GLOBAL_NX_VERSION) {
+        packageVersionsWeCareAbout.unshift({
+            package: 'nx (global)',
+            version: globalThis.GLOBAL_NX_VERSION,
+        });
+    }
+    const outOfSyncPackageGroup = findMisalignedPackagesForPackage(nxPackageJson);
+    return {
+        pm,
+        pmVersion,
+        localPlugins,
+        communityPlugins,
+        packageVersionsWeCareAbout,
+        outOfSyncPackageGroup,
+        projectGraphError,
+    };
+}
+exports.getReportData = getReportData;
+async function findLocalPlugins(nxJson) {
+    try {
+        const projectGraph = await (0, project_graph_1.createProjectGraphAsync)({ exitOnError: true });
+        const localPlugins = await (0, local_plugins_1.getLocalWorkspacePlugins)((0, project_graph_1.readProjectsConfigurationFromProjectGraph)(projectGraph), nxJson);
+        return Array.from(localPlugins.keys());
+    }
+    catch {
+        return [];
+    }
+}
+function readPackageJson(p) {
+    try {
+        return (0, package_json_1.readModulePackageJson)(p, (0, installation_directory_1.getNxRequirePaths)()).packageJson;
+    }
+    catch {
+        return null;
+    }
+}
+function readPackageVersion(p) {
+    return readPackageJson(p)?.version;
+}
+function findMisalignedPackagesForPackage(base) {
+    const misalignedPackages = [];
+    let migrateTarget = base.version;
+    const { packageGroup } = (0, package_json_1.readNxMigrateConfig)(base);
+    for (const entry of packageGroup ?? []) {
+        const { package: packageName, version } = entry;
+        // should be aligned
+        if (version === '*') {
+            const installedVersion = readPackageVersion(packageName);
+            if (installedVersion && installedVersion !== base.version) {
+                if ((0, semver_1.valid)(installedVersion) && (0, semver_1.gt)(installedVersion, migrateTarget)) {
+                    migrateTarget = installedVersion;
+                }
+                misalignedPackages.push({
+                    name: packageName,
+                    version: installedVersion,
+                });
+            }
+        }
+    }
+    return misalignedPackages.length
+        ? {
+            basePackage: base.name,
+            misalignedPackages,
+            migrateTarget: `${base.name}@${migrateTarget}`,
+        }
+        : undefined;
+}
+exports.findMisalignedPackagesForPackage = findMisalignedPackagesForPackage;
+function findInstalledCommunityPlugins() {
+    const installedPlugins = (0, installed_plugins_1.findInstalledPlugins)();
+    return installedPlugins.filter((dep) => dep.name !== 'nx' &&
+        !exports.patternsWeIgnoreInCommunityReport.some((pattern) => typeof pattern === 'string'
+            ? pattern === dep.name
+            : pattern.test(dep.name)));
+}
+exports.findInstalledCommunityPlugins = findInstalledCommunityPlugins;
+function findInstalledPackagesWeCareAbout() {
+    const packagesWeMayCareAbout = {};
+    // TODO (v19): Remove workaround for hiding @nrwl packages when matching @nx package is found.
+    const packageChangeMap = {
+        '@nrwl/nx-plugin': '@nx/plugin',
+        '@nx/plugin': '@nrwl/nx-plugin',
+        '@nrwl/eslint-plugin-nx': '@nx/eslint-plugin',
+        '@nx/eslint-plugin': '@nrwl/eslint-plugin-nx',
+        '@nrwl/nx-cloud': 'nx-cloud',
+    };
+    for (const pkg of exports.packagesWeCareAbout) {
+        const v = readPackageVersion(pkg);
+        if (v) {
+            // If its a @nrwl scoped package, keep the version if there is no
+            // corresponding @nx scoped package, or it has a different version.
+            if (pkg.startsWith('@nrwl/')) {
+                const otherPackage = packageChangeMap[pkg] ?? pkg.replace('@nrwl/', '@nx/');
+                const otherVersion = packagesWeMayCareAbout[otherPackage];
+                if (!otherVersion || v !== otherVersion) {
+                    packagesWeMayCareAbout[pkg] = v;
+                }
+                // If its a @nx scoped package, always keep the version, and
+                // remove the corresponding @nrwl scoped package if it exists.
+            }
+            else if (pkg.startsWith('@nx/')) {
+                const otherPackage = packageChangeMap[pkg] ?? pkg.replace('@nx/', '@nrwl/');
+                const otherVersion = packagesWeMayCareAbout[otherPackage];
+                if (otherVersion && v === otherVersion) {
+                    delete packagesWeMayCareAbout[otherPackage];
+                }
+                packagesWeMayCareAbout[pkg] = v;
+            }
+            else {
+                packagesWeMayCareAbout[pkg] = v;
+            }
+        }
+    }
+    return Object.entries(packagesWeMayCareAbout).map(([pkg, version]) => ({
+        package: pkg,
+        version,
+    }));
+}
+exports.findInstalledPackagesWeCareAbout = findInstalledPackagesWeCareAbout;
+function isNativeAvailable() {
+    try {
+        require('../../native');
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/src/command-line/reset/command-object.d.ts

@@ -0,0 +1,2 @@
+import { CommandModule } from 'yargs';
+export declare const yargsResetCommand: CommandModule;

package/src/command-line/reset/command-object.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.yargsResetCommand = void 0;
+exports.yargsResetCommand = {
+    command: 'reset',
+    describe: 'Clears all the cached Nx artifacts and metadata about the workspace and shuts down the Nx Daemon.',
+    aliases: ['clear-cache'],
+    handler: async () => (await Promise.resolve().then(() => require('./reset'))).resetHandler(),
+};

package/src/command-line/reset/reset.d.ts

@@ -0,0 +1 @@
+export declare function resetHandler(): Promise<void>;

package/src/command-line/reset/reset.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resetHandler = void 0;
+const fs_extra_1 = require("fs-extra");
+const client_1 = require("../../daemon/client/client");
+const cache_directory_1 = require("../../utils/cache-directory");
+const output_1 = require("../../utils/output");
+async function resetHandler() {
+    output_1.output.note({
+        title: 'Resetting the Nx workspace cache and stopping the Nx Daemon.',
+        bodyLines: [`This might take a few minutes.`],
+    });
+    await client_1.daemonClient.stop();
+    output_1.output.log({ title: 'Daemon Server - Stopped' });
+    (0, fs_extra_1.rmSync)(cache_directory_1.cacheDir, { recursive: true, force: true });
+    if (cache_directory_1.projectGraphCacheDirectory !== cache_directory_1.cacheDir) {
+        (0, fs_extra_1.rmSync)(cache_directory_1.projectGraphCacheDirectory, { recursive: true, force: true });
+    }
+    output_1.output.success({
+        title: 'Successfully reset the Nx workspace.',
+    });
+}
+exports.resetHandler = resetHandler;

package/src/command-line/run/command-object.d.ts

@@ -0,0 +1,6 @@
+import { CommandModule } from 'yargs';
+export declare const yargsRunCommand: CommandModule;
+/**
+ * Handles the infix notation for running a target.
+ */
+export declare const yargsNxInfixCommand: CommandModule;

package/src/command-line/run/command-object.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.yargsNxInfixCommand = exports.yargsRunCommand = void 0;
+const shared_options_1 = require("../yargs-utils/shared-options");
+exports.yargsRunCommand = {
+    command: 'run [project][:target][:configuration] [_..]',
+    describe: `Run a target for a project
+    (e.g., nx run myapp:serve:production).
+
+    You can also use the infix notation to run a target:
+    (e.g., nx serve myapp --configuration=production)
+
+    You can skip the use of Nx cache by using the --skip-nx-cache option.`,
+    builder: (yargs) => (0, shared_options_1.withRunOneOptions)((0, shared_options_1.withBatch)(yargs)),
+    handler: async (args) => (await Promise.resolve().then(() => require('./run-one'))).runOne(process.cwd(), (0, shared_options_1.withOverrides)(args)),
+};
+/**
+ * Handles the infix notation for running a target.
+ */
+exports.yargsNxInfixCommand = {
+    ...exports.yargsRunCommand,
+    command: '$0 <target> [project] [_..]',
+    describe: 'Run a target for a project',
+    handler: async (args) => (await Promise.resolve().then(() => require('./run-one'))).runOne(process.cwd(), (0, shared_options_1.withOverrides)(args, 0)),
+};

package/src/command-line/run/executor-utils.d.ts

@@ -0,0 +1,7 @@
+import { ExecutorConfig } from '../../config/misc-interfaces';
+import { ProjectConfiguration } from '../../config/workspace-json-project-json';
+export declare function normalizeExecutorSchema(schema: Partial<ExecutorConfig['schema']>): ExecutorConfig['schema'];
+export declare function getExecutorInformation(nodeModule: string, executor: string, root: string, projects: Record<string, ProjectConfiguration>): ExecutorConfig & {
+    isNgCompat: boolean;
+    isNxExecutor: boolean;
+};

package/src/command-line/run/executor-utils.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getExecutorInformation = exports.normalizeExecutorSchema = void 0;
+const path_1 = require("path");
+const nx_plugin_1 = require("../../utils/nx-plugin");
+const fileutils_1 = require("../../utils/fileutils");
+const schema_utils_1 = require("../../config/schema-utils");
+const installation_directory_1 = require("../../utils/installation-directory");
+function normalizeExecutorSchema(schema) {
+    const version = (schema.version ??= 1);
+    return {
+        version,
+        outputCapture: schema.outputCapture ?? version < 2 ? 'direct-nodejs' : 'pipe',
+        properties: !schema.properties || typeof schema.properties !== 'object'
+            ? {}
+            : schema.properties,
+        ...schema,
+    };
+}
+exports.normalizeExecutorSchema = normalizeExecutorSchema;
+function cacheKey(nodeModule, executor, root) {
+    return `${root}:${nodeModule}:${executor}`;
+}
+const cachedExecutorInformation = {};
+function getExecutorInformation(nodeModule, executor, root, projects) {
+    try {
+        const key = cacheKey(nodeModule, executor, root);
+        if (cachedExecutorInformation[key])
+            return cachedExecutorInformation[key];
+        const { executorsFilePath, executorConfig, isNgCompat } = readExecutorJson(nodeModule, executor, root, projects);
+        const executorsDir = (0, path_1.dirname)(executorsFilePath);
+        const schemaPath = (0, schema_utils_1.resolveSchema)(executorConfig.schema, executorsDir);
+        const schema = normalizeExecutorSchema((0, fileutils_1.readJsonFile)(schemaPath));
+        const implementationFactory = (0, schema_utils_1.getImplementationFactory)(executorConfig.implementation, executorsDir);
+        const batchImplementationFactory = executorConfig.batchImplementation
+            ? (0, schema_utils_1.getImplementationFactory)(executorConfig.batchImplementation, executorsDir)
+            : null;
+        const hasherFactory = executorConfig.hasher
+            ? (0, schema_utils_1.getImplementationFactory)(executorConfig.hasher, executorsDir)
+            : null;
+        const res = {
+            schema,
+            implementationFactory,
+            batchImplementationFactory,
+            hasherFactory,
+            isNgCompat,
+            isNxExecutor: !isNgCompat,
+        };
+        cachedExecutorInformation[key] = res;
+        return res;
+    }
+    catch (e) {
+        throw new Error(`Unable to resolve ${nodeModule}:${executor}.\n${e.message}`);
+    }
+}
+exports.getExecutorInformation = getExecutorInformation;
+function readExecutorJson(nodeModule, executor, root, projects) {
+    const { json: packageJson, path: packageJsonPath } = (0, nx_plugin_1.readPluginPackageJson)(nodeModule, projects, root
+        ? [root, __dirname, process.cwd(), ...(0, installation_directory_1.getNxRequirePaths)()]
+        : [__dirname, process.cwd(), ...(0, installation_directory_1.getNxRequirePaths)()]);
+    const executorsFile = packageJson.executors ?? packageJson.builders;
+    if (!executorsFile) {
+        throw new Error(`The "${nodeModule}" package does not support Nx executors.`);
+    }
+    const executorsFilePath = require.resolve((0, path_1.join)((0, path_1.dirname)(packageJsonPath), executorsFile));
+    const executorsJson = (0, fileutils_1.readJsonFile)(executorsFilePath);
+    const executorConfig = executorsJson.executors?.[executor] || executorsJson.builders?.[executor];
+    if (!executorConfig) {
+        throw new Error(`Cannot find executor '${executor}' in ${executorsFilePath}.`);
+    }
+    const isNgCompat = !executorsJson.executors?.[executor];
+    return { executorsFilePath, executorConfig, isNgCompat };
+}

package/src/command-line/run/run-one.d.ts

@@ -0,0 +1,7 @@
+import { TargetDependencyConfig } from '../../config/workspace-json-project-json';
+export declare function runOne(cwd: string, args: {
+    [k: string]: any;
+}, extraTargetDependencies?: Record<string, (TargetDependencyConfig | string)[]>, extraOptions?: {
+    excludeTaskDependencies: boolean;
+    loadDotEnvFiles: boolean;
+}): Promise<void>;

package/src/command-line/run/run-one.js

@@ -0,0 +1,117 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runOne = void 0;
+const run_command_1 = require("../../tasks-runner/run-command");
+const command_line_utils_1 = require("../../utils/command-line-utils");
+const connect_to_nx_cloud_1 = require("../connect/connect-to-nx-cloud");
+const perf_hooks_1 = require("perf_hooks");
+const project_graph_1 = require("../../project-graph/project-graph");
+const workspace_root_1 = require("../../utils/workspace-root");
+const split_target_1 = require("../../utils/split-target");
+const output_1 = require("../../utils/output");
+const configuration_1 = require("../../config/configuration");
+const calculate_default_project_name_1 = require("../../config/calculate-default-project-name");
+const workspace_configuration_check_1 = require("../../utils/workspace-configuration-check");
+const graph_1 = require("../graph/graph");
+async function runOne(cwd, args, extraTargetDependencies = {}, extraOptions = { excludeTaskDependencies: false, loadDotEnvFiles: true }) {
+    perf_hooks_1.performance.mark('code-loading:end');
+    perf_hooks_1.performance.measure('code-loading', 'init-local', 'code-loading:end');
+    (0, workspace_configuration_check_1.workspaceConfigurationCheck)();
+    const nxJson = (0, configuration_1.readNxJson)();
+    const projectGraph = await (0, project_graph_1.createProjectGraphAsync)({ exitOnError: true });
+    const opts = parseRunOneOptions(cwd, args, projectGraph, nxJson);
+    const { nxArgs, overrides } = (0, command_line_utils_1.splitArgsIntoNxArgsAndOverrides)({
+        ...opts.parsedArgs,
+        configuration: opts.configuration,
+        targets: [opts.target],
+    }, 'run-one', { printWarnings: args.graph !== 'stdout' }, nxJson);
+    if (nxArgs.verbose) {
+        process.env.NX_VERBOSE_LOGGING = 'true';
+    }
+    if (nxArgs.help) {
+        await (await Promise.resolve().then(() => require('./run'))).printTargetRunHelp(opts, workspace_root_1.workspaceRoot);
+        process.exit(0);
+    }
+    await (0, connect_to_nx_cloud_1.connectToNxCloudIfExplicitlyAsked)(nxArgs);
+    const { projects } = getProjects(projectGraph, opts.project);
+    if (nxArgs.graph) {
+        const projectNames = projects.map((t) => t.name);
+        const file = (0, command_line_utils_1.readGraphFileFromGraphArg)(nxArgs);
+        return await (0, graph_1.generateGraph)({
+            watch: false,
+            open: true,
+            view: 'tasks',
+            targets: nxArgs.targets,
+            projects: projectNames,
+            file,
+        }, projectNames);
+    }
+    else {
+        const status = await (0, run_command_1.runCommand)(projects, projectGraph, { nxJson }, nxArgs, overrides, opts.project, extraTargetDependencies, extraOptions);
+        process.exit(status);
+    }
+}
+exports.runOne = runOne;
+function getProjects(projectGraph, project) {
+    if (!projectGraph.nodes[project]) {
+        output_1.output.error({
+            title: `Cannot find project '${project}'`,
+        });
+        process.exit(1);
+    }
+    let projects = [projectGraph.nodes[project]];
+    let projectsMap = {
+        [project]: projectGraph.nodes[project],
+    };
+    return { projects, projectsMap };
+}
+const targetAliases = {
+    b: 'build',
+    e: 'e2e',
+    l: 'lint',
+    s: 'serve',
+    t: 'test',
+};
+function parseRunOneOptions(cwd, parsedArgs, projectGraph, nxJson) {
+    const defaultProjectName = (0, calculate_default_project_name_1.calculateDefaultProjectName)(cwd, workspace_root_1.workspaceRoot, (0, project_graph_1.readProjectsConfigurationFromProjectGraph)(projectGraph), nxJson);
+    let project;
+    let target;
+    let configuration;
+    if (parsedArgs['project:target:configuration']?.indexOf(':') > -1) {
+        // run case
+        [project, target, configuration] = (0, split_target_1.splitTarget)(parsedArgs['project:target:configuration'], projectGraph);
+        // this is to account for "nx npmsript:dev"
+        if (project && !target && defaultProjectName) {
+            target = project;
+            project = defaultProjectName;
+        }
+    }
+    else {
+        target = parsedArgs.target ?? parsedArgs['project:target:configuration'];
+    }
+    if (parsedArgs.project) {
+        project = parsedArgs.project;
+    }
+    if (!project && defaultProjectName) {
+        project = defaultProjectName;
+    }
+    if (!project || !target) {
+        throw new Error(`Both project and target have to be specified`);
+    }
+    if (targetAliases[target]) {
+        target = targetAliases[target];
+    }
+    if (parsedArgs.configuration) {
+        configuration = parsedArgs.configuration;
+    }
+    else if (parsedArgs.prod) {
+        configuration = 'production';
+    }
+    const res = { project, target, configuration, parsedArgs };
+    delete parsedArgs['c'];
+    delete parsedArgs['project:target:configuration'];
+    delete parsedArgs['configuration'];
+    delete parsedArgs['prod'];
+    delete parsedArgs['project'];
+    return res;
+}

package/src/command-line/run/run.d.ts

@@ -0,0 +1,51 @@
+import { Schema } from '../../utils/params';
+import { ProjectsConfigurations } from '../../config/workspace-json-project-json';
+import { ExecutorContext } from '../../config/misc-interfaces';
+import { TaskGraph } from '../../config/task-graph';
+export interface Target {
+    project: string;
+    target: string;
+    configuration?: string;
+}
+export declare function printRunHelp(opts: {
+    project: string;
+    target: string;
+}, schema: Schema, plugin: {
+    plugin: string;
+    entity: string;
+}): void;
+export declare function validateProject(projects: ProjectsConfigurations, projectName: string): void;
+/**
+ * Loads and invokes executor.
+ *
+ * This is analogous to invoking executor from the terminal, with the exception
+ * that the params aren't parsed from the string, but instead provided parsed already.
+ *
+ * Apart from that, it works the same way:
+ *
+ * - it will load the workspace configuration
+ * - it will resolve the target
+ * - it will load the executor and the schema
+ * - it will load the options for the appropriate configuration
+ * - it will run the validations and will set the default
+ * - and, of course, it will invoke the executor
+ *
+ * Example:
+ *
+ * ```typescript
+ * for await (const s of await runExecutor({project: 'myproj', target: 'serve'}, {watch: true}, context)) {
+ *   // s.success
+ * }
+ * ```
+ *
+ * Note that the return value is a promise of an iterator, so you need to await before iterating over it.
+ */
+export declare function runExecutor<T extends {
+    success: boolean;
+}>(targetDescription: Target, overrides: {
+    [k: string]: any;
+}, context: ExecutorContext): Promise<AsyncIterableIterator<T>>;
+export declare function printTargetRunHelp(targetDescription: Target, root: string): Promise<any>;
+export declare function run(cwd: string, root: string, targetDescription: Target, overrides: {
+    [k: string]: any;
+}, isVerbose: boolean, taskGraph: TaskGraph): Promise<any>;