nx 17.0.3 → 17.0.5

package/src/utils/ab-testing.d.ts

@@ -1,7 +1,40 @@
+export type MessageOptionKey = 'yes' | 'skip';
+declare const messageOptions: {
+    readonly setupNxCloud: readonly [{
+        readonly code: "enable-caching";
+        readonly message: "Would you like remote caching to make your build faster?";
+        readonly initial: 0;
+        readonly choices: readonly [{
+            readonly value: "yes";
+            readonly name: "Yes";
+        }, {
+            readonly value: "skip";
+            readonly name: "Skip for now";
+        }];
+        readonly footer: "\nRead more about remote cache at https://nx.dev/ci/features/remote-cache";
+        readonly hint: "\n(it's free and can be disabled any time)";
+    }];
+    readonly setupViewLogs: readonly [{
+        readonly code: "connect-to-view-logs";
+        readonly message: "To view the logs, Nx needs to connect your workspace to Nx Cloud and upload the most recent run details";
+        readonly initial: 0;
+        readonly choices: readonly [{
+            readonly value: "yes";
+            readonly name: "Yes";
+            readonly hint: "Connect to Nx Cloud and upload the run details";
+        }, {
+            readonly value: "skip";
+            readonly name: "No";
+        }];
+        readonly footer: "\nRead more about remote cache at https://nx.dev/ci/features/remote-cache";
+        readonly hint: "\n(it's free and can be disabled any time)";
+    }];
+};
+export type MessageKey = keyof typeof messageOptions;
+export type MessageData = typeof messageOptions[MessageKey][number];
 export declare class PromptMessages {
-    private messages;
     private selectedMessages;
-    getPromptMessage(key: string): string;
+    getPrompt(key: MessageKey): MessageData;
     codeOfSelectedPromptMessage(key: string): string;
 }
 export declare const messages: PromptMessages;
@@ -15,3 +48,4 @@ export declare function recordStat(opts: {
     useCloud: boolean;
     meta: string;
 }): Promise<void>;
+export {};

package/src/utils/ab-testing.js

@@ -2,39 +2,57 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.recordStat = exports.messages = exports.PromptMessages = void 0;
 const is_ci_1 = require("./is-ci");
-class PromptMessages {
-    constructor() {
-        this.messages = {
-            nxCloudCreation: [
-                {
-                    code: 'set-up-distributed-caching-ci',
-                    message: `Enable distributed caching to make your CI faster`,
-                },
+const messageOptions = {
+    setupNxCloud: [
+        {
+            code: 'enable-caching',
+            message: `Would you like remote caching to make your build faster?`,
+            initial: 0,
+            choices: [
+                { value: 'yes', name: 'Yes' },
+                { value: 'skip', name: 'Skip for now' },
             ],
-            nxCloudMigration: [
+            footer: '\nRead more about remote cache at https://nx.dev/ci/features/remote-cache',
+            hint: `\n(it's free and can be disabled any time)`,
+        },
+    ],
+    setupViewLogs: [
+        {
+            code: 'connect-to-view-logs',
+            message: `To view the logs, Nx needs to connect your workspace to Nx Cloud and upload the most recent run details`,
+            initial: 0,
+            choices: [
                 {
-                    code: 'make-ci-faster',
-                    message: `Enable distributed caching to make your CI faster?`,
+                    value: 'yes',
+                    name: 'Yes',
+                    hint: 'Connect to Nx Cloud and upload the run details',
                 },
+                { value: 'skip', name: 'No' },
             ],
-        };
+            footer: '\nRead more about remote cache at https://nx.dev/ci/features/remote-cache',
+            hint: `\n(it's free and can be disabled any time)`,
+        },
+    ],
+};
+class PromptMessages {
+    constructor() {
         this.selectedMessages = {};
     }
-    getPromptMessage(key) {
+    getPrompt(key) {
         if (this.selectedMessages[key] === undefined) {
             if (process.env.NX_GENERATE_DOCS_PROCESS === 'true') {
                 this.selectedMessages[key] = 0;
             }
             else {
-                this.selectedMessages[key] = Math.floor(Math.random() * this.messages[key].length);
+                this.selectedMessages[key] = Math.floor(Math.random() * messageOptions[key].length);
             }
         }
-        return this.messages[key][this.selectedMessages[key]].message;
+        return messageOptions[key][this.selectedMessages[key]];
     }
     codeOfSelectedPromptMessage(key) {
         if (this.selectedMessages[key] === undefined)
             return null;
-        return this.messages[key][this.selectedMessages[key]].code;
+        return messageOptions[key][this.selectedMessages[key]].code;
     }
 }
 exports.PromptMessages = PromptMessages;

package/src/utils/assert-workspace-validity.js

@@ -9,7 +9,7 @@ function assertWorkspaceValidity(projects, nxJson) {
         const projectConfiguration = projects[project];
         graph[project] = {
             name: project,
-            type: projectConfiguration.projectType === 'library' ? 'lib' : 'app',
+            type: projectConfiguration.projectType === 'library' ? 'lib' : 'app', // missing fallback to `e2e`
             data: {
                 ...projectConfiguration,
             },

package/src/utils/cache-directory.d.ts

@@ -2,4 +2,5 @@
  * Path to the directory where Nx stores its cache and daemon-related files.
  */
 export declare const cacheDir: string;
+export declare function cacheDirectoryForWorkspace(workspaceRoot: string): string;
 export declare const projectGraphCacheDirectory: string;

package/src/utils/cache-directory.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.projectGraphCacheDirectory = exports.cacheDir = void 0;
+exports.projectGraphCacheDirectory = exports.cacheDirectoryForWorkspace = exports.cacheDir = void 0;
 const fs_1 = require("fs");
 const path_1 = require("path");
 const fileutils_1 = require("./fileutils");
@@ -52,5 +52,9 @@ function defaultCacheDirectory(root) {
  * Path to the directory where Nx stores its cache and daemon-related files.
  */
 exports.cacheDir = cacheDirectory(workspace_root_1.workspaceRoot, readCacheDirectoryProperty(workspace_root_1.workspaceRoot));
+function cacheDirectoryForWorkspace(workspaceRoot) {
+    return cacheDirectory(workspaceRoot, readCacheDirectoryProperty(workspaceRoot));
+}
+exports.cacheDirectoryForWorkspace = cacheDirectoryForWorkspace;
 exports.projectGraphCacheDirectory = absolutePath(workspace_root_1.workspaceRoot, process.env.NX_PROJECT_GRAPH_CACHE_DIRECTORY ??
     defaultCacheDirectory(workspace_root_1.workspaceRoot));

package/src/utils/child-process.d.ts

@@ -1,5 +1,19 @@
 /// <reference types="node" />
-import { ExecSyncOptions } from 'child_process';
+import { type ExecOptions, type ExecSyncOptions } from 'child_process';
+import { ChildProcess } from '../native';
 export declare function runNxSync(cmd: string, options?: ExecSyncOptions & {
     cwd?: string;
 }): void;
+export declare function runNxAsync(cmd: string, options?: ExecOptions & {
+    cwd?: string;
+    silent?: boolean;
+}): Promise<void>;
+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;
+}

package/src/utils/child-process.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.runNxSync = void 0;
+exports.PseudoTtyProcess = exports.runNxAsync = exports.runNxSync = void 0;
 const child_process_1 = require("child_process");
 const fs_1 = require("fs");
 const path_1 = require("path");
@@ -25,3 +25,93 @@ function runNxSync(cmd, options) {
     (0, child_process_1.execSync)(`${baseCmd} ${cmd}`, options);
 }
 exports.runNxSync = runNxSync;
+async function runNxAsync(cmd, options) {
+    let baseCmd;
+    if ((0, fs_1.existsSync)((0, path_1.join)(workspace_root_1.workspaceRoot, 'package.json'))) {
+        baseCmd = `${(0, package_manager_1.getPackageManagerCommand)().exec} nx`;
+    }
+    else {
+        options ??= {};
+        options.cwd ??= process.cwd();
+        const offsetFromRoot = (0, path_1.relative)(options.cwd, (0, workspace_root_1.workspaceRootInner)(options.cwd, null));
+        if (process.platform === 'win32') {
+            baseCmd = '.\\' + (0, path_1.join)(`${offsetFromRoot}`, 'nx.bat');
+        }
+        else {
+            baseCmd = './' + (0, path_1.join)(`${offsetFromRoot}`, 'nx');
+        }
+    }
+    const silent = options?.silent ?? true;
+    if (options?.silent) {
+        delete options.silent;
+    }
+    await new Promise((resolve, reject) => {
+        const child = (0, child_process_1.exec)(`${baseCmd} ${cmd}`, options, (error, stdout, stderr) => {
+            if (error) {
+                reject(error);
+            }
+            else {
+                resolve(stdout);
+            }
+        });
+        if (!silent) {
+            child.stdout?.pipe(process.stdout);
+            child.stderr?.pipe(process.stderr);
+        }
+    });
+}
+exports.runNxAsync = runNxAsync;
+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;
+    }
+}
+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;

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

@@ -84,7 +84,8 @@ function splitArgsIntoNxArgsAndOverrides(args, mode, options = { printWarnings:
             }
         }
         if (!nxArgs.base) {
-            nxArgs.base = nxJson.affected?.defaultBase || 'main';
+            nxArgs.base =
+                nxJson.defaultBase ?? nxJson.affected?.defaultBase ?? 'main';
             // No user-provided arguments to set the affected criteria, so inform the user of the defaults being used
             if (options.printWarnings &&
                 !nxArgs.head &&

package/src/utils/exit-codes.d.ts

@@ -0,0 +1,6 @@
+/// <reference types="node" />
+/**
+ * Translates NodeJS signals to numeric exit code
+ * @param signal
+ */
+export declare function signalToCode(signal: NodeJS.Signals): number;

package/src/utils/exit-codes.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.signalToCode = void 0;
+/**
+ * Translates NodeJS signals to numeric exit code
+ * @param signal
+ */
+function signalToCode(signal) {
+    switch (signal) {
+        case 'SIGHUP':
+            return 128 + 1;
+        case 'SIGINT':
+            return 128 + 2;
+        case 'SIGTERM':
+            return 128 + 15;
+        default:
+            return 128;
+    }
+}
+exports.signalToCode = signalToCode;

package/src/utils/fileutils.d.ts

@@ -1,4 +1,5 @@
 /// <reference types="node" />
+/// <reference types="@types/node/ts4.8/fs" />
 import type { JsonParseOptions, JsonSerializeOptions } from './json';
 import { PathLike } from 'fs';
 export interface JsonReadOptions extends JsonParseOptions {

package/src/utils/find-matching-projects.js

@@ -1,11 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getMatchingStringsWithCache = exports.findMatchingProjects = void 0;
-const minimatch = require("minimatch");
+const minimatch_1 = require("minimatch");
 const validPatternTypes = [
-    'name',
-    'tag',
-    'directory',
+    'name', // Pattern is based on the project's name
+    'tag', // Pattern is based on the project's tags
+    'directory', // Pattern is based on the project's root directory
     'unlabeled', // Pattern was passed without specifying a type
 ];
 const globCharacters = ['*', '|', '{', '}', '(', ')'];
@@ -177,7 +177,7 @@ exports.getMatchingStringsWithCache = (() => {
         }
         const patternCache = minimatchCache.get(pattern);
         if (!regexCache.has(pattern)) {
-            const regex = minimatch.makeRe(pattern, { dot: true });
+            const regex = minimatch_1.minimatch.makeRe(pattern, { dot: true });
             if (regex) {
                 regexCache.set(pattern, regex);
             }

package/src/utils/find-workspace-root.js

@@ -22,6 +22,7 @@ function findWorkspaceRoot(dir) {
 exports.findWorkspaceRoot = findWorkspaceRoot;
 function isAngularCliInstalled(root) {
     try {
+        // nx-ignore-next-line
         require.resolve('@angular/cli', {
             paths: [root],
         });

package/src/utils/ignore.js

@@ -27,7 +27,14 @@ 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',
+        '.yarn/cache',
+    ];
     return root ? paths.map((x) => (0, path_1.joinPathFragments)(root, x)) : paths;
 }
 exports.getAlwaysIgnore = getAlwaysIgnore;

package/src/utils/json-diff.d.ts

@@ -15,3 +15,4 @@ export interface JsonChange extends Change {
 export declare function isJsonChange(change: Change): change is JsonChange;
 export declare function jsonDiff(lhs: any, rhs: any): JsonChange[];
 export declare function walkJsonTree(json: any, currPath: string[], visitor: (path: string[], value: any) => boolean): void;
+export declare function deepEquals(a: any, b: any): boolean;

package/src/utils/json-diff.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.walkJsonTree = exports.jsonDiff = exports.isJsonChange = exports.JsonDiffType = void 0;
+exports.deepEquals = exports.walkJsonTree = exports.jsonDiff = exports.isJsonChange = exports.JsonDiffType = void 0;
 var JsonDiffType;
 (function (JsonDiffType) {
     JsonDiffType["Deleted"] = "JsonPropertyDeleted";
@@ -109,3 +109,4 @@ function deepEquals(a, b) {
         return deepEquals(aValue, b[key]);
     }, true);
 }
+exports.deepEquals = deepEquals;

package/src/utils/json.js

@@ -15,7 +15,9 @@ const code_frames_1 = require("./code-frames");
  */
 function parseJson(input, options) {
     try {
-        return JSON.parse(input);
+        if (options?.expectComments !== true) {
+            return JSON.parse(input);
+        }
     }
     catch { }
     options = { allowTrailingComma: true, ...options };

package/src/utils/logger.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.stripIndent = exports.logger = exports.NX_ERROR = exports.NX_PREFIX = void 0;
 const chalk = require("chalk");
-exports.NX_PREFIX = `${chalk.cyan('>')} ${chalk.inverse(chalk.bold(chalk.cyan(' NX ')))}`;
+exports.NX_PREFIX = chalk.inverse(chalk.bold(chalk.cyan(' NX ')));
 exports.NX_ERROR = chalk.inverse(chalk.bold(chalk.red(' ERROR ')));
 exports.logger = {
     warn: (s) => console.warn(chalk.bold(chalk.yellow(s))),

package/src/utils/nx-cloud-utils.d.ts

@@ -1,4 +1,4 @@
 import { NxJsonConfiguration } from '../config/nx-json';
-export declare function isNxCloudUsed(nxJson: NxJsonConfiguration): boolean;
+export declare function isNxCloudUsed(nxJson: NxJsonConfiguration): string | boolean;
 export declare function getNxCloudUrl(nxJson: NxJsonConfiguration): string;
 export declare function getNxCloudToken(nxJson: NxJsonConfiguration): string;

package/src/utils/nx-cloud-utils.js

@@ -2,21 +2,26 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getNxCloudToken = exports.getNxCloudUrl = exports.isNxCloudUsed = void 0;
 function isNxCloudUsed(nxJson) {
-    return (!!nxJson.nxCloudAccessToken ||
+    return (process.env.NX_CLOUD_ACCESS_TOKEN ||
+        !!nxJson.nxCloudAccessToken ||
         !!Object.values(nxJson.tasksRunnerOptions ?? {}).find((r) => r.runner == '@nrwl/nx-cloud' || r.runner == 'nx-cloud'));
 }
 exports.isNxCloudUsed = isNxCloudUsed;
 function getNxCloudUrl(nxJson) {
     const cloudRunner = Object.values(nxJson.tasksRunnerOptions ?? {}).find((r) => r.runner == '@nrwl/nx-cloud' || r.runner == 'nx-cloud');
-    if (!cloudRunner && !nxJson.nxCloudAccessToken)
+    if (!cloudRunner &&
+        !(nxJson.nxCloudAccessToken || process.env.NX_CLOUD_ACCESS_TOKEN))
         throw new Error('nx-cloud runner not found in nx.json');
     return cloudRunner?.options?.url ?? nxJson.nxCloudUrl ?? 'https://nx.app';
 }
 exports.getNxCloudUrl = getNxCloudUrl;
 function getNxCloudToken(nxJson) {
     const cloudRunner = Object.values(nxJson.tasksRunnerOptions ?? {}).find((r) => r.runner == '@nrwl/nx-cloud' || r.runner == 'nx-cloud');
-    if (!cloudRunner && !nxJson.nxCloudAccessToken)
+    if (!cloudRunner &&
+        !(nxJson.nxCloudAccessToken || process.env.NX_CLOUD_ACCESS_TOKEN))
         throw new Error('nx-cloud runner not found in nx.json');
-    return cloudRunner?.options.accessToken ?? nxJson.nxCloudAccessToken;
+    return (process.env.NX_CLOUD_ACCESS_TOKEN ??
+        cloudRunner?.options.accessToken ??
+        nxJson.nxCloudAccessToken);
 }
 exports.getNxCloudToken = getNxCloudToken;

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

@@ -10,20 +10,31 @@ import { RawProjectGraphDependency } from '../project-graph/project-graph-builde
 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) => {
-    projects?: Record<string, ProjectConfiguration>;
+export type CreateNodesFunction<T = unknown> = (projectConfigurationFile: string, options: T | undefined, context: CreateNodesContext) => CreateNodesResult | Promise<CreateNodesResult>;
+export interface CreateNodesResult {
+    /**
+     * A map of project root -> project configuration
+     */
+    projects?: Record<string, Optional<ProjectConfiguration, 'root'>>;
+    /**
+     * A map of external node name -> external node. External nodes do not have a root, so the key is their name.
+     */
     externalNodes?: Record<string, ProjectGraphExternalNode>;
-};
+}
 /**
  * A pair of file patterns and {@link CreateNodesFunction}
  */
 export type CreateNodes<T = unknown> = readonly [
-    projectFilePattern: string,
+    configFilePattern: string,
     createNodesFunction: CreateNodesFunction<T>
 ];
 /**
@@ -60,17 +71,17 @@ export type CreateDependencies<T = unknown> = (options: T | undefined, context:
 /**
  * A plugin for Nx which creates nodes and dependencies for the {@link ProjectGraph}
  */
-export type NxPluginV2<T = unknown> = {
+export type NxPluginV2<TOptions = unknown> = {
     name: string;
     /**
      * Provides a file pattern and function that retrieves configuration info from
      * those files. e.g. { '**\/*.csproj': buildProjectsFromCsProjFile }
      */
-    createNodes?: CreateNodes<T>;
+    createNodes?: CreateNodes;
     /**
      * Provides a function to analyze files to create dependencies for the {@link ProjectGraph}
      */
-    createDependencies?: CreateDependencies<T>;
+    createDependencies?: CreateDependencies<TOptions>;
 };
 export * from './nx-plugin.deprecated';
 /**
@@ -80,20 +91,24 @@ export type NxPlugin = NxPluginV1 | NxPluginV2;
 export type LoadedNxPlugin = {
     plugin: NxPluginV2 & Pick<NxPluginV1, 'processProjectGraph'>;
     options?: unknown;
+    include?: string[];
+    exclude?: string[];
 };
-export declare function loadNxPluginAsync(pluginConfiguration: PluginConfiguration, paths: string[], root: string): Promise<LoadedNxPlugin>;
-/**
- * @deprecated Use loadNxPlugins instead.
- */
-export declare function loadNxPluginsSync(plugins: NxJsonConfiguration['plugins'], paths?: string[], root?: string): LoadedNxPlugin[];
-export declare function loadNxPlugins(plugins: PluginConfiguration[], paths?: string[], root?: string): Promise<LoadedNxPlugin[]>;
+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, paths?: string[]): {
+export declare function readPluginPackageJson(pluginName: string, projects: Record<string, ProjectConfiguration>, paths?: string[]): {
     path: string;
     json: PackageJson;
 };
-export declare function resolveLocalNxPlugin(importPath: string, root?: string): {
+export declare function resolveLocalNxPlugin(importPath: string, nxJsonConfiguration: NxJsonConfiguration, projects: Record<string, ProjectConfiguration>, root?: string): {
     path: string;
     projectConfig: ProjectConfiguration;
 } | null;
@@ -106,3 +121,5 @@ 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,26 +1,31 @@
 import { ProjectGraphProcessor } from '../config/project-graph';
 import { TargetConfiguration } from '../config/workspace-json-project-json';
+import { LoadedNxPlugin } from './nx-plugin';
 /**
- * @deprecated Add targets to the projects in a {@link CreateNodes} function instead. This will be removed in Nx 18
+ * @deprecated Add targets to the projects in a {@link CreateNodes} function instead. This will be removed in Nx 19
  */
 export type ProjectTargetConfigurator = (file: string) => Record<string, TargetConfiguration>;
 /**
- * @deprecated Use {@link NxPluginV2} instead. This will be removed in Nx 18
+ * @deprecated Use {@link NxPluginV2} instead. This will be removed in Nx 19
  */
 export type NxPluginV1 = {
     name: string;
     /**
-     * @deprecated Use {@link CreateNodes} and {@link CreateDependencies} instead. This will be removed in Nx 18
+     * @deprecated Use {@link CreateNodes} and {@link CreateDependencies} instead. This will be removed in Nx 19
      */
     processProjectGraph?: ProjectGraphProcessor;
     /**
-     * @deprecated Add targets to the projects inside of {@link CreateNodes} instead. This will be removed in Nx 18
+     * @deprecated Add targets to the projects inside of {@link CreateNodes} instead. This will be removed in Nx 19
      */
     registerProjectTargets?: ProjectTargetConfigurator;
     /**
      * A glob pattern to search for non-standard project files.
      * @example: ["*.csproj", "pom.xml"]
-     * @deprecated Use {@link CreateNodes} instead. This will be removed in Nx 18
+     * @deprecated Use {@link CreateNodes} instead. This will be removed in Nx 19
      */
     projectFilePatterns?: string[];
 };
+/**
+ * @todo(@agentender) v19: Remove this fn when we remove readWorkspaceConfig
+ */
+export declare function getDefaultPluginsSync(root: string): LoadedNxPlugin[];

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

@@ -1,2 +1,25 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+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 package_json_workspaces_1 = require("../plugins/package-json-workspaces");
+/**
+ * @todo(@agentender) v19: Remove this fn when we remove readWorkspaceConfig
+ */
+function getDefaultPluginsSync(root) {
+    const plugins = [
+        require('../plugins/js'),
+        ...((0, angular_json_1.shouldMergeAngularProjects)(root, false)
+            ? [require('../adapter/angular-json').NxAngularJsonPlugin]
+            : []),
+        target_defaults_plugin_1.TargetDefaultsPlugin,
+        (0, package_json_workspaces_1.getNxPackageJsonWorkspacesPlugin)(root),
+        project_json_1.ProjectJsonProjectsPlugin,
+    ];
+    return plugins.map((p) => ({
+        plugin: p,
+    }));
+}
+exports.getDefaultPluginsSync = getDefaultPluginsSync;