nx 18.1.0 → 18.1.2

package/src/tasks-runner/pseudo-terminal.d.ts

@@ -0,0 +1,43 @@
+/// <reference types="node" />
+import { ChildProcess, RustPseudoTerminal } from '../native';
+import { PseudoIPCServer } from './pseudo-ipc';
+import { Serializable } from 'child_process';
+export declare function getPseudoTerminal(skipSupportCheck?: boolean): PseudoTerminal;
+export declare class PseudoTerminal {
+    private rustPseudoTerminal;
+    private pseudoIPCPath;
+    private pseudoIPC;
+    private initialized;
+    static isSupported(): boolean;
+    constructor(rustPseudoTerminal: RustPseudoTerminal);
+    init(): Promise<void>;
+    runCommand(command: string, { cwd, jsEnv, quiet, }?: {
+        cwd?: string;
+        jsEnv?: Record<string, string>;
+        quiet?: boolean;
+    }): PseudoTtyProcess;
+    fork(id: string, script: string, { cwd, jsEnv, quiet, }: {
+        cwd?: string;
+        jsEnv?: Record<string, string>;
+        quiet?: boolean;
+    }): Promise<PseudoTtyProcessWithSend>;
+    sendMessageToChildren(message: Serializable): void;
+    onMessageFromChildren(callback: (message: Serializable) => void): void;
+    private setupProcessListeners;
+    private shutdownPseudoIPC;
+}
+export declare class PseudoTtyProcess {
+    private childProcess;
+    isAlive: boolean;
+    exitCallbacks: any[];
+    constructor(childProcess: ChildProcess);
+    onExit(callback: (code: number) => void): void;
+    onOutput(callback: (message: string) => void): void;
+    kill(): void;
+}
+export declare class PseudoTtyProcessWithSend extends PseudoTtyProcess {
+    private id;
+    private pseudoIpc;
+    constructor(_childProcess: ChildProcess, id: string, pseudoIpc: PseudoIPCServer);
+    send(message: Serializable): void;
+}

package/src/tasks-runner/pseudo-terminal.js

@@ -0,0 +1,159 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PseudoTtyProcessWithSend = exports.PseudoTtyProcess = exports.PseudoTerminal = exports.getPseudoTerminal = void 0;
+const native_1 = require("../native");
+const pseudo_ipc_1 = require("./pseudo-ipc");
+const socket_utils_1 = require("../daemon/socket-utils");
+const os = require("os");
+let pseudoTerminal;
+function getPseudoTerminal(skipSupportCheck = false) {
+    if (!skipSupportCheck && !PseudoTerminal.isSupported()) {
+        throw new Error('Pseudo terminal is not supported on this platform.');
+    }
+    pseudoTerminal ??= new PseudoTerminal(new native_1.RustPseudoTerminal());
+    return pseudoTerminal;
+}
+exports.getPseudoTerminal = getPseudoTerminal;
+class PseudoTerminal {
+    static isSupported() {
+        return process.stdout.isTTY && supportedPtyPlatform();
+    }
+    constructor(rustPseudoTerminal) {
+        this.rustPseudoTerminal = rustPseudoTerminal;
+        this.pseudoIPCPath = (0, socket_utils_1.FORKED_PROCESS_OS_SOCKET_PATH)(process.pid.toString());
+        this.pseudoIPC = new pseudo_ipc_1.PseudoIPCServer(this.pseudoIPCPath);
+        this.initialized = false;
+        this.setupProcessListeners();
+    }
+    async init() {
+        if (this.initialized) {
+            return;
+        }
+        await this.pseudoIPC.init();
+        this.initialized = true;
+    }
+    runCommand(command, { cwd, jsEnv, quiet, } = {}) {
+        return new PseudoTtyProcess(this.rustPseudoTerminal.runCommand(command, cwd, jsEnv, quiet));
+    }
+    async fork(id, script, { cwd, jsEnv, quiet, }) {
+        if (!this.initialized) {
+            throw new Error('Call init() before forking processes');
+        }
+        const cp = new PseudoTtyProcessWithSend(this.rustPseudoTerminal.fork(id, script, this.pseudoIPCPath, cwd, jsEnv, quiet), id, this.pseudoIPC);
+        await this.pseudoIPC.waitForChildReady(id);
+        return cp;
+    }
+    sendMessageToChildren(message) {
+        this.pseudoIPC.sendMessageToChildren(message);
+    }
+    onMessageFromChildren(callback) {
+        this.pseudoIPC.onMessageFromChildren(callback);
+    }
+    setupProcessListeners() {
+        const shutdown = () => {
+            this.shutdownPseudoIPC();
+        };
+        process.on('SIGINT', () => {
+            this.shutdownPseudoIPC();
+        });
+        process.on('SIGTERM', () => {
+            this.shutdownPseudoIPC();
+        });
+        process.on('SIGHUP', () => {
+            this.shutdownPseudoIPC();
+        });
+        process.on('exit', () => {
+            this.shutdownPseudoIPC();
+        });
+    }
+    shutdownPseudoIPC() {
+        if (this.initialized) {
+            this.pseudoIPC.close();
+        }
+    }
+}
+exports.PseudoTerminal = PseudoTerminal;
+class PseudoTtyProcess {
+    constructor(childProcess) {
+        this.childProcess = childProcess;
+        this.isAlive = true;
+        this.exitCallbacks = [];
+        childProcess.onExit((message) => {
+            this.isAlive = false;
+            const exitCode = messageToCode(message);
+            this.exitCallbacks.forEach((cb) => cb(exitCode));
+        });
+    }
+    onExit(callback) {
+        this.exitCallbacks.push(callback);
+    }
+    onOutput(callback) {
+        this.childProcess.onOutput(callback);
+    }
+    kill() {
+        try {
+            this.childProcess.kill();
+        }
+        catch {
+            // when the child process completes before we explicitly call kill, this will throw
+            // do nothing
+        }
+        finally {
+            if (this.isAlive == true) {
+                this.isAlive = false;
+            }
+        }
+    }
+}
+exports.PseudoTtyProcess = PseudoTtyProcess;
+class PseudoTtyProcessWithSend extends PseudoTtyProcess {
+    constructor(_childProcess, id, pseudoIpc) {
+        super(_childProcess);
+        this.id = id;
+        this.pseudoIpc = pseudoIpc;
+    }
+    send(message) {
+        this.pseudoIpc.sendMessageToChild(this.id, message);
+    }
+}
+exports.PseudoTtyProcessWithSend = PseudoTtyProcessWithSend;
+function messageToCode(message) {
+    if (message.startsWith('Terminated by ')) {
+        switch (message.replace('Terminated by ', '').trim()) {
+            case 'Termination':
+                return 143;
+            case 'Interrupt':
+                return 130;
+            default:
+                return 128;
+        }
+    }
+    else if (message.startsWith('Exited with code ')) {
+        return parseInt(message.replace('Exited with code ', '').trim());
+    }
+    else if (message === 'Success') {
+        return 0;
+    }
+    else {
+        return 1;
+    }
+}
+function supportedPtyPlatform() {
+    if (process.platform !== 'win32') {
+        return true;
+    }
+    let windowsVersion = os.release().split('.');
+    let windowsBuild = windowsVersion[2];
+    if (!windowsBuild) {
+        return false;
+    }
+    // Mininum supported Windows version:
+    // https://en.wikipedia.org/wiki/Windows_10,_version_1809
+    // https://learn.microsoft.com/en-us/windows/console/createpseudoconsole#requirements
+    if (+windowsBuild < 17763) {
+        return false;
+    }
+    else {
+        return true;
+    }
+}

package/src/tasks-runner/task-orchestrator.js

@@ -3,13 +3,17 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.TaskOrchestrator = void 0;
 const events_1 = require("events");
 const perf_hooks_1 = require("perf_hooks");
+const path_1 = require("path");
+const run_commands_impl_1 = require("../executors/run-commands/run-commands.impl");
 const forked_process_task_runner_1 = require("./forked-process-task-runner");
 const cache_1 = require("./cache");
 const utils_1 = require("./utils");
 const tasks_schedule_1 = require("./tasks-schedule");
 const hash_task_1 = require("../hasher/hash-task");
 const task_env_1 = require("./task-env");
-const os = require("os");
+const workspace_root_1 = require("../utils/workspace-root");
+const output_1 = require("../utils/output");
+const params_1 = require("../utils/params");
 class TaskOrchestrator {
     // endregion internal state
     constructor(hasher, initiatingProject, projectGraph, taskGraph, options, bail, daemon) {
@@ -49,7 +53,6 @@ class TaskOrchestrator {
         await Promise.all(threads);
         perf_hooks_1.performance.mark('task-execution:end');
         perf_hooks_1.performance.measure('task-execution', 'task-execution:start', 'task-execution:end');
-        this.forkedProcessTaskRunner.destroy();
         this.cache.removeOldCacheRecords();
         return this.completedTasks;
     }
@@ -205,20 +208,53 @@ class TaskOrchestrator {
         let results = doNotSkipCache ? await this.applyCachedResults([task]) : [];
         // the task wasn't cached
         if (results.length === 0) {
-            // cache prep
-            const { code, terminalOutput } = await this.runTaskInForkedProcess(task, env, pipeOutput, temporaryOutputPath, streamOutput);
-            results.push({
-                task,
-                status: code === 0 ? 'success' : 'failure',
-                terminalOutput,
-            });
+            const shouldPrefix = streamOutput && process.env.NX_PREFIX_OUTPUT === 'true';
+            const targetConfiguration = (0, utils_1.getTargetConfigurationForTask)(task, this.projectGraph);
+            if (process.env.NX_RUN_COMMANDS_DIRECTLY !== 'false' &&
+                targetConfiguration.executor === 'nx:run-commands' &&
+                !shouldPrefix) {
+                const { schema } = (0, utils_1.getExecutorForTask)(task, this.projectGraph);
+                const isRunOne = this.initiatingProject != null;
+                const combinedOptions = (0, params_1.combineOptionsForExecutor)(task.overrides, task.target.configuration ?? targetConfiguration.defaultConfiguration, targetConfiguration, schema, task.target.project, (0, path_1.relative)(task.projectRoot ?? workspace_root_1.workspaceRoot, process.cwd()), process.env.NX_VERBOSE_LOGGING === 'true');
+                if (streamOutput) {
+                    const args = (0, utils_1.getPrintableCommandArgsForTask)(task);
+                    output_1.output.logCommand(args.join(' '));
+                }
+                const { success, terminalOutput } = await (0, run_commands_impl_1.default)({
+                    ...combinedOptions,
+                    env,
+                    usePty: isRunOne && !this.tasksSchedule.hasTasks(),
+                    streamOutput,
+                }, {
+                    root: workspace_root_1.workspaceRoot, // only root is needed in runCommandsImpl
+                });
+                const status = success ? 'success' : 'failure';
+                if (!streamOutput) {
+                    this.options.lifeCycle.printTaskTerminalOutput(task, status, terminalOutput);
+                }
+                results.push({
+                    task,
+                    status,
+                    terminalOutput,
+                });
+            }
+            else {
+                // cache prep
+                const { code, terminalOutput } = await this.runTaskInForkedProcess(task, env, pipeOutput, temporaryOutputPath, streamOutput);
+                results.push({
+                    task,
+                    status: code === 0 ? 'success' : 'failure',
+                    terminalOutput,
+                });
+            }
         }
         await this.postRunSteps([task], results, doNotSkipCache, { groupId });
     }
     async runTaskInForkedProcess(task, env, pipeOutput, temporaryOutputPath, streamOutput) {
         try {
-            let usePtyFork = process.env.NX_NATIVE_COMMAND_RUNNER !== 'false' &&
-                supportedPtyPlatform();
+            const usePtyFork = process.env.NX_NATIVE_COMMAND_RUNNER !== 'false';
+            // Disable the pseudo terminal if this is a run-many
+            const disablePseudoTerminal = !this.initiatingProject;
             // execution
             const { code, terminalOutput } = usePtyFork
                 ? await this.forkedProcessTaskRunner.forkProcess(task, {
@@ -227,6 +263,7 @@ class TaskOrchestrator {
                     pipeOutput,
                     taskGraph: this.taskGraph,
                     env,
+                    disablePseudoTerminal,
                 })
                 : await this.forkedProcessTaskRunner.forkProcessLegacy(task, {
                     temporaryOutputPath,
@@ -338,7 +375,7 @@ class TaskOrchestrator {
             if (process.env.NX_NATIVE_COMMAND_RUNNER !== 'false') {
                 return true;
             }
-            const { schema } = await (0, utils_1.getExecutorForTask)(task, this.projectGraph);
+            const { schema } = (0, utils_1.getExecutorForTask)(task, this.projectGraph);
             return (schema.outputCapture === 'pipe' ||
                 process.env.NX_STREAM_OUTPUT === 'true');
         }
@@ -376,22 +413,3 @@ class TaskOrchestrator {
     }
 }
 exports.TaskOrchestrator = TaskOrchestrator;
-function supportedPtyPlatform() {
-    if (process.platform !== 'win32') {
-        return true;
-    }
-    let windowsVersion = os.release().split('.');
-    let windowsBuild = windowsVersion[2];
-    if (!windowsBuild) {
-        return false;
-    }
-    // Mininum supported Windows version:
-    // https://en.wikipedia.org/wiki/Windows_10,_version_1809
-    // https://learn.microsoft.com/en-us/windows/console/createpseudoconsole#requirements
-    if (+windowsBuild < 17763) {
-        return false;
-    }
-    else {
-        return true;
-    }
-}

package/src/tasks-runner/tasks-schedule.js

@@ -89,7 +89,7 @@ class TasksSchedule {
         const batchMap = {};
         for (const root of this.notScheduledTaskGraph.roots) {
             const rootTask = this.notScheduledTaskGraph.tasks[root];
-            const executorName = await (0, utils_1.getExecutorNameForTask)(rootTask, this.projectGraph);
+            const executorName = (0, utils_1.getExecutorNameForTask)(rootTask, this.projectGraph);
             await this.processTaskForBatches(batchMap, rootTask, executorName, true);
         }
         for (const [executorName, taskGraph] of Object.entries(batchMap)) {
@@ -105,8 +105,8 @@ class TasksSchedule {
         if (!this.canBatchTaskBeScheduled(task.id, batches[rootExecutorName])) {
             return;
         }
-        const { batchImplementationFactory } = await (0, utils_1.getExecutorForTask)(task, this.projectGraph);
-        const executorName = await (0, utils_1.getExecutorNameForTask)(task, this.projectGraph);
+        const { batchImplementationFactory } = (0, utils_1.getExecutorForTask)(task, this.projectGraph);
+        const executorName = (0, utils_1.getExecutorNameForTask)(task, this.projectGraph);
         if (rootExecutorName !== executorName) {
             return;
         }

package/src/tasks-runner/utils.d.ts

@@ -1,7 +1,7 @@
 import { Task, TaskGraph } from '../config/task-graph';
 import { ProjectGraph, ProjectGraphProjectNode } from '../config/project-graph';
-import { TargetDependencyConfig } from '../config/workspace-json-project-json';
-import { CustomHasher } from '../config/misc-interfaces';
+import { TargetConfiguration, TargetDependencyConfig } from '../config/workspace-json-project-json';
+import { CustomHasher, ExecutorConfig } from '../config/misc-interfaces';
 export declare function getCommandAsString(execCommand: string, task: Task): string;
 export declare function getDependencyConfigs({ project, target }: {
     project: string;
@@ -23,12 +23,13 @@ export declare function transformLegacyOutputs(projectRoot: string, error: Inval
 export declare function getOutputsForTargetAndConfiguration(task: Task, node: ProjectGraphProjectNode): string[];
 export declare function getOutputsForTargetAndConfiguration(target: Task['target'] | Task, overrides: Task['overrides'] | ProjectGraphProjectNode, node: ProjectGraphProjectNode): string[];
 export declare function interpolate(template: string, data: any): string;
-export declare function getExecutorNameForTask(task: Task, projectGraph: ProjectGraph): Promise<string>;
-export declare function getExecutorForTask(task: Task, projectGraph: ProjectGraph): Promise<import("../config/misc-interfaces").ExecutorConfig & {
+export declare function getTargetConfigurationForTask(task: Task, projectGraph: ProjectGraph): TargetConfiguration | undefined;
+export declare function getExecutorNameForTask(task: Task, projectGraph: ProjectGraph): string;
+export declare function getExecutorForTask(task: Task, projectGraph: ProjectGraph): ExecutorConfig & {
     isNgCompat: boolean;
     isNxExecutor: boolean;
-}>;
-export declare function getCustomHasher(task: Task, projectGraph: ProjectGraph): Promise<CustomHasher> | null;
+};
+export declare function getCustomHasher(task: Task, projectGraph: ProjectGraph): CustomHasher | null;
 export declare function removeTasksFromTaskGraph(graph: TaskGraph, ids: string[]): TaskGraph;
 export declare function removeIdsFromGraph<T>(graph: {
     roots: string[];

package/src/tasks-runner/utils.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.unparse = exports.isCacheableTask = exports.shouldStreamOutput = exports.getSerializedArgsForTask = exports.getPrintableCommandArgsForTask = exports.getCliPath = exports.calculateReverseDeps = exports.removeIdsFromGraph = exports.removeTasksFromTaskGraph = exports.getCustomHasher = exports.getExecutorForTask = exports.getExecutorNameForTask = exports.interpolate = exports.getOutputsForTargetAndConfiguration = exports.transformLegacyOutputs = exports.validateOutputs = exports.getOutputs = exports.expandDependencyConfigSyntaxSugar = exports.getDependencyConfigs = exports.getCommandAsString = void 0;
+exports.unparse = exports.isCacheableTask = exports.shouldStreamOutput = exports.getSerializedArgsForTask = exports.getPrintableCommandArgsForTask = exports.getCliPath = exports.calculateReverseDeps = exports.removeIdsFromGraph = exports.removeTasksFromTaskGraph = exports.getCustomHasher = exports.getExecutorForTask = exports.getExecutorNameForTask = exports.getTargetConfigurationForTask = exports.interpolate = exports.getOutputsForTargetAndConfiguration = exports.transformLegacyOutputs = exports.validateOutputs = exports.getOutputs = exports.expandDependencyConfigSyntaxSugar = exports.getDependencyConfigs = exports.getCommandAsString = void 0;
 const output_1 = require("../utils/output");
 const path_1 = require("path");
 const workspace_root_1 = require("../utils/workspace-root");
@@ -177,19 +177,23 @@ function interpolate(template, data) {
     });
 }
 exports.interpolate = interpolate;
-async function getExecutorNameForTask(task, projectGraph) {
+function getTargetConfigurationForTask(task, projectGraph) {
     const project = projectGraph.nodes[task.target.project].data;
-    return project.targets[task.target.target].executor;
+    return project.targets[task.target.target];
+}
+exports.getTargetConfigurationForTask = getTargetConfigurationForTask;
+function getExecutorNameForTask(task, projectGraph) {
+    return getTargetConfigurationForTask(task, projectGraph)?.executor;
 }
 exports.getExecutorNameForTask = getExecutorNameForTask;
-async function getExecutorForTask(task, projectGraph) {
-    const executor = await getExecutorNameForTask(task, projectGraph);
+function getExecutorForTask(task, projectGraph) {
+    const executor = getExecutorNameForTask(task, projectGraph);
     const [nodeModule, executorName] = executor.split(':');
     return (0, executor_utils_1.getExecutorInformation)(nodeModule, executorName, workspace_root_1.workspaceRoot, (0, project_graph_1.readProjectsConfigurationFromProjectGraph)(projectGraph).projects);
 }
 exports.getExecutorForTask = getExecutorForTask;
-async function getCustomHasher(task, projectGraph) {
-    const factory = (await getExecutorForTask(task, projectGraph)).hasherFactory;
+function getCustomHasher(task, projectGraph) {
+    const factory = getExecutorForTask(task, projectGraph).hasherFactory;
     return factory ? factory() : null;
 }
 exports.getCustomHasher = getCustomHasher;

package/src/utils/ignore.js

@@ -27,7 +27,7 @@ function getIgnoredGlobs(root = workspace_root_1.workspaceRoot, prependRoot = tr
 }
 exports.getIgnoredGlobs = getIgnoredGlobs;
 function getAlwaysIgnore(root) {
-    const paths = ['node_modules', '**/node_modules', '.git'];
+    const paths = ['node_modules', '**/node_modules', '.git', '.nx', '.vscode'];
     return root ? paths.map((x) => (0, path_1.joinPathFragments)(root, x)) : paths;
 }
 exports.getAlwaysIgnore = getAlwaysIgnore;

package/src/utils/logger.d.ts

@@ -7,6 +7,5 @@ export declare const logger: {
     log: (...s: any[]) => void;
     debug: (...s: any[]) => void;
     fatal: (...s: any[]) => void;
-    verbose: (...s: any[]) => void;
 };
 export declare function stripIndent(str: string): string;

package/src/utils/logger.js

@@ -34,11 +34,6 @@ exports.logger = {
     fatal: (...s) => {
         console.error(...s);
     },
-    verbose: (...s) => {
-        if (process.env.NX_VERBOSE_LOGGING) {
-            console.log(...s);
-        }
-    },
 };
 function stripIndent(str) {
     const match = str.match(/^[ \t]*(?=\S)/gm);

package/src/{project-graph/plugins/public-api.d.ts → utils/nx-plugin.d.ts}

@@ -1,21 +1,25 @@
-import { NxPluginV1 } from '../../utils/nx-plugin.deprecated';
-import { FileMap, ProjectGraph, ProjectGraphExternalNode } from '../../config/project-graph';
-import { ProjectConfiguration } from '../../config/workspace-json-project-json';
-import { NxJsonConfiguration } from '../../config/nx-json';
-import { RawProjectGraphDependency } from '../project-graph-builder';
+import { FileMap, ProjectGraph, ProjectGraphExternalNode } from '../config/project-graph';
+import { PackageJson } from './package-json';
+import { ProjectConfiguration } from '../config/workspace-json-project-json';
+import { NxJsonConfiguration, PluginConfiguration } from '../config/nx-json';
+import { NxPluginV1 } from './nx-plugin.deprecated';
+import { RawProjectGraphDependency } from '../project-graph/project-graph-builder';
 /**
  * Context for {@link CreateNodesFunction}
  */
 export interface CreateNodesContext {
     readonly nxJsonConfiguration: NxJsonConfiguration;
     readonly workspaceRoot: string;
+    /**
+     * The subset of configuration files which match the createNodes pattern
+     */
+    readonly configFiles: string[];
 }
 /**
  * A function which parses a configuration file into a set of nodes.
  * Used for creating nodes for the {@link ProjectGraph}
  */
 export type CreateNodesFunction<T = unknown> = (projectConfigurationFile: string, options: T | undefined, context: CreateNodesContext) => CreateNodesResult | Promise<CreateNodesResult>;
-export type Optional<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
 export interface CreateNodesResult {
     /**
      * A map of project root -> project configuration
@@ -30,7 +34,7 @@ export interface CreateNodesResult {
  * A pair of file patterns and {@link CreateNodesFunction}
  */
 export type CreateNodes<T = unknown> = readonly [
-    projectFilePattern: string,
+    configFilePattern: string,
     createNodesFunction: CreateNodesFunction<T>
 ];
 /**
@@ -79,7 +83,41 @@ export type NxPluginV2<TOptions = unknown> = {
      */
     createDependencies?: CreateDependencies<TOptions>;
 };
+export * from './nx-plugin.deprecated';
 /**
  * A plugin for Nx
  */
 export type NxPlugin = NxPluginV1 | NxPluginV2;
+export type LoadedNxPlugin = {
+    plugin: NxPluginV2 & Pick<NxPluginV1, 'processProjectGraph'>;
+    options?: unknown;
+};
+export declare const nxPluginCache: Map<string, LoadedNxPlugin['plugin']>;
+export declare function getPluginPathAndName(moduleName: string, paths: string[], projects: Record<string, ProjectConfiguration>, root: string): {
+    pluginPath: string;
+    name: any;
+};
+export declare function loadNxPluginAsync(pluginConfiguration: PluginConfiguration, paths: string[], projects: Record<string, ProjectConfiguration>, root: string): Promise<LoadedNxPlugin>;
+export declare function loadNxPlugins(plugins: PluginConfiguration[], paths?: string[], root?: string, projects?: Record<string, ProjectConfiguration>): Promise<LoadedNxPlugin[]>;
+export declare function ensurePluginIsV2(plugin: NxPlugin): NxPluginV2;
+export declare function isNxPluginV2(plugin: NxPlugin): plugin is NxPluginV2;
+export declare function isNxPluginV1(plugin: NxPlugin): plugin is NxPluginV1;
+export declare function readPluginPackageJson(pluginName: string, projects: Record<string, ProjectConfiguration>, paths?: string[]): {
+    path: string;
+    json: PackageJson;
+};
+export declare function resolveLocalNxPlugin(importPath: string, nxJsonConfiguration: NxJsonConfiguration, projects: Record<string, ProjectConfiguration>, root?: string): {
+    path: string;
+    projectConfig: ProjectConfiguration;
+} | null;
+/**
+ * Register swc-node or ts-node if they are not currently registered
+ * with some default settings which work well for Nx plugins.
+ */
+export declare function registerPluginTSTranspiler(): void;
+/**
+ * Unregister the ts-node transpiler if it is registered
+ */
+export declare function unregisterPluginTSTranspiler(): void;
+export declare function getDefaultPlugins(root: string): Promise<LoadedNxPlugin[]>;
+type Optional<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;

package/src/utils/nx-plugin.deprecated.d.ts

@@ -1,6 +1,6 @@
 import { ProjectGraphProcessor } from '../config/project-graph';
 import { TargetConfiguration } from '../config/workspace-json-project-json';
-import { NxPluginV2 } from '../project-graph/plugins';
+import { LoadedNxPlugin } from './nx-plugin';
 /**
  * @deprecated Add targets to the projects in a {@link CreateNodes} function instead. This will be removed in Nx 19
  */
@@ -28,6 +28,4 @@ export type NxPluginV1 = {
 /**
  * @todo(@agentender) v19: Remove this fn when we remove readWorkspaceConfig
  */
-export declare function getDefaultPluginsSync(root: string): {
-    plugin: NxPluginV2;
-}[];
+export declare function getDefaultPluginsSync(root: string): LoadedNxPlugin[];

package/src/utils/nx-plugin.deprecated.js

@@ -4,7 +4,7 @@ exports.getDefaultPluginsSync = void 0;
 const angular_json_1 = require("../adapter/angular-json");
 const project_json_1 = require("../plugins/project-json/build-nodes/project-json");
 const target_defaults_plugin_1 = require("../plugins/target-defaults/target-defaults-plugin");
-const PackageJsonWorkspacesPlugin = require("../plugins/package-json-workspaces");
+const package_json_workspaces_1 = require("../plugins/package-json-workspaces");
 /**
  * @todo(@agentender) v19: Remove this fn when we remove readWorkspaceConfig
  */
@@ -14,9 +14,9 @@ function getDefaultPluginsSync(root) {
         ...((0, angular_json_1.shouldMergeAngularProjects)(root, false)
             ? [require('../adapter/angular-json').NxAngularJsonPlugin]
             : []),
-        target_defaults_plugin_1.default,
-        PackageJsonWorkspacesPlugin,
-        project_json_1.default,
+        target_defaults_plugin_1.TargetDefaultsPlugin,
+        (0, package_json_workspaces_1.getNxPackageJsonWorkspacesPlugin)(root),
+        project_json_1.ProjectJsonProjectsPlugin,
     ];
     return plugins.map((p) => ({
         plugin: p,