@ohos-ports/nx 17.3.2-beta.0

package/src/plugins/js/utils/register.js

@@ -0,0 +1,215 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTsNodeCompilerOptions = exports.registerTsConfigPaths = exports.registerTranspiler = exports.getTranspiler = exports.getTsNodeTranspiler = exports.getSwcTranspiler = exports.registerTsProject = void 0;
+const path_1 = require("path");
+const logger_1 = require("../../../utils/logger");
+const fs_1 = require("fs");
+const workspace_root_1 = require("../../../utils/workspace-root");
+const swcNodeInstalled = packageIsInstalled('@swc-node/register');
+const tsNodeInstalled = packageIsInstalled('ts-node/register');
+let ts;
+function registerTsProject(path, configFilename) {
+    const tsConfigPath = configFilename ? (0, path_1.join)(path, configFilename) : path;
+    const compilerOptions = readCompilerOptions(tsConfigPath);
+    const cleanupFunctions = [
+        registerTsConfigPaths(tsConfigPath),
+        registerTranspiler(compilerOptions),
+    ];
+    return () => {
+        for (const fn of cleanupFunctions) {
+            fn();
+        }
+    };
+}
+exports.registerTsProject = registerTsProject;
+function getSwcTranspiler(compilerOptions) {
+    // These are requires to prevent it from registering when it shouldn't
+    const register = require('@swc-node/register/register')
+        .register;
+    let rootTsConfig = (0, path_1.join)(workspace_root_1.workspaceRoot, 'tsconfig.base.json');
+    if ((0, fs_1.existsSync)(rootTsConfig)) {
+        process.env.SWC_NODE_PROJECT = rootTsConfig;
+    }
+    const cleanupFn = register(compilerOptions);
+    return typeof cleanupFn === 'function' ? cleanupFn : () => { };
+}
+exports.getSwcTranspiler = getSwcTranspiler;
+function getTsNodeTranspiler(compilerOptions) {
+    const { register } = require('ts-node');
+    // ts-node doesn't provide a cleanup method
+    const service = register({
+        transpileOnly: true,
+        compilerOptions: getTsNodeCompilerOptions(compilerOptions),
+        // we already read and provide the compiler options, so prevent ts-node from reading them again
+        skipProject: true,
+    });
+    const { transpiler, swc } = service.options;
+    // Don't warn if a faster transpiler is enabled
+    if (!transpiler && !swc) {
+        warnTsNodeUsage();
+    }
+    return () => {
+        service.enabled(false);
+    };
+}
+exports.getTsNodeTranspiler = getTsNodeTranspiler;
+function getTranspiler(compilerOptions) {
+    const preferTsNode = process.env.NX_PREFER_TS_NODE === 'true';
+    if (!ts) {
+        ts = require('typescript');
+    }
+    compilerOptions.lib = ['es2021'];
+    compilerOptions.module = ts.ModuleKind.CommonJS;
+    compilerOptions.target = ts.ScriptTarget.ES2021;
+    compilerOptions.inlineSourceMap = true;
+    compilerOptions.skipLibCheck = true;
+    if (swcNodeInstalled && !preferTsNode) {
+        return () => getSwcTranspiler(compilerOptions);
+    }
+    // We can fall back on ts-node if it's available
+    if (tsNodeInstalled) {
+        return () => getTsNodeTranspiler(compilerOptions);
+    }
+}
+exports.getTranspiler = getTranspiler;
+/**
+ * Register ts-node or swc-node given a set of compiler options.
+ *
+ * Note: Several options require enums from typescript. To avoid importing typescript,
+ * use import type + raw values
+ *
+ * @returns cleanup method
+ */
+function registerTranspiler(compilerOptions) {
+    // Function to register transpiler that returns cleanup function
+    const transpiler = getTranspiler(compilerOptions);
+    if (!transpiler) {
+        warnNoTranspiler();
+        return () => { };
+    }
+    return transpiler();
+}
+exports.registerTranspiler = registerTranspiler;
+/**
+ * @param tsConfigPath Adds the paths from a tsconfig file into node resolutions
+ * @returns cleanup function
+ */
+function registerTsConfigPaths(tsConfigPath) {
+    try {
+        /**
+         * Load the ts config from the source project
+         */
+        const tsconfigPaths = loadTsConfigPaths();
+        const tsConfigResult = tsconfigPaths.loadConfig(tsConfigPath);
+        /**
+         * Register the custom workspace path mappings with node so that workspace libraries
+         * can be imported and used within project
+         */
+        if (tsConfigResult.resultType === 'success') {
+            return tsconfigPaths.register({
+                baseUrl: tsConfigResult.absoluteBaseUrl,
+                paths: tsConfigResult.paths,
+            });
+        }
+    }
+    catch (err) {
+        if (err instanceof Error) {
+            throw new Error(`Unable to load ${tsConfigPath}: ` + err.message);
+        }
+    }
+    throw new Error(`Unable to load ${tsConfigPath}`);
+}
+exports.registerTsConfigPaths = registerTsConfigPaths;
+function readCompilerOptions(tsConfigPath) {
+    const preferTsNode = process.env.NX_PREFER_TS_NODE === 'true';
+    if (swcNodeInstalled && !preferTsNode) {
+        const { readDefaultTsConfig, } = require('@swc-node/register/read-default-tsconfig');
+        return readDefaultTsConfig(tsConfigPath);
+    }
+    else {
+        return readCompilerOptionsWithTypescript(tsConfigPath);
+    }
+}
+function readCompilerOptionsWithTypescript(tsConfigPath) {
+    if (!ts) {
+        ts = require('typescript');
+    }
+    const { readConfigFile, parseJsonConfigFileContent, sys } = ts;
+    const jsonContent = readConfigFile(tsConfigPath, sys.readFile);
+    const { options } = parseJsonConfigFileContent(jsonContent.config, sys, (0, path_1.dirname)(tsConfigPath));
+    // This property is returned in compiler options for some reason, but not part of the typings.
+    // ts-node fails on unknown props, so we have to remove it.
+    delete options.configFilePath;
+    return options;
+}
+function loadTsConfigPaths() {
+    try {
+        return require('tsconfig-paths');
+    }
+    catch {
+        warnNoTsconfigPaths();
+    }
+}
+function warnTsNodeUsage() {
+    logger_1.logger.warn((0, logger_1.stripIndent)(`${logger_1.NX_PREFIX} Falling back to ts-node for local typescript execution. This may be a little slower.
+  - To fix this, ensure @swc-node/register and @swc/core have been installed`));
+}
+function warnNoTsconfigPaths() {
+    logger_1.logger.warn((0, logger_1.stripIndent)(`${logger_1.NX_PREFIX} Unable to load tsconfig-paths, workspace libraries may be inaccessible.
+  - To fix this, install tsconfig-paths with npm/yarn/pnpm`));
+}
+function warnNoTranspiler() {
+    logger_1.logger.warn((0, logger_1.stripIndent)(`${logger_1.NX_PREFIX} Unable to locate swc-node or ts-node. Nx will be unable to run local ts files without transpiling.
+  - To fix this, ensure @swc-node/register and @swc/core have been installed`));
+}
+function packageIsInstalled(m) {
+    try {
+        const p = require.resolve(m);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * ts-node requires string values for enum based typescript options.
+ * `register`'s signature just types the field as `object`, so we
+ * unfortunately do not get any kind of type safety on this.
+ */
+function getTsNodeCompilerOptions(compilerOptions) {
+    if (!ts) {
+        ts = require('typescript');
+    }
+    const flagMap = {
+        module: 'ModuleKind',
+        target: 'ScriptTarget',
+        moduleDetection: 'ModuleDetectionKind',
+        newLine: 'NewLineKind',
+        moduleResolution: 'ModuleResolutionKind',
+        importsNotUsedAsValues: 'ImportsNotUsedAsValues',
+    };
+    const result = {
+        ...compilerOptions,
+    };
+    for (const flag in flagMap) {
+        if (compilerOptions[flag]) {
+            result[flag] = ts[flagMap[flag]][compilerOptions[flag]];
+        }
+    }
+    delete result.pathsBasePath;
+    delete result.configFilePath;
+    // instead of mapping to enum value we just remove it as it shouldn't ever need to be set for ts-node
+    delete result.jsx;
+    // lib option is in the format `lib.es2022.d.ts`, so we need to remove the leading `lib.` and trailing `.d.ts` to make it valid
+    result.lib = result.lib?.map((value) => {
+        return value.replace(/^lib\./, '').replace(/\.d\.ts$/, '');
+    });
+    if (result.moduleResolution) {
+        result.moduleResolution =
+            result.moduleResolution === 'NodeJs'
+                ? 'node'
+                : result.moduleResolution.toLowerCase();
+    }
+    return result;
+}
+exports.getTsNodeCompilerOptions = getTsNodeCompilerOptions;

package/src/plugins/js/utils/typescript.d.ts

@@ -0,0 +1,14 @@
+import type * as ts from 'typescript';
+import type { Node, SyntaxKind } from 'typescript';
+export declare function readTsConfig(tsConfigPath: string): ts.ParsedCommandLine;
+/**
+ * Find a module based on its import
+ *
+ * @param importExpr Import used to resolve to a module
+ * @param filePath
+ * @param tsConfigPath
+ */
+export declare function resolveModuleByImport(importExpr: string, filePath: string, tsConfigPath: string): string;
+export declare function getRootTsConfigFileName(): string | null;
+export declare function getRootTsConfigPath(): string | null;
+export declare function findNodes(node: Node, kind: SyntaxKind | SyntaxKind[], max?: number): Node[];

package/src/plugins/js/utils/typescript.js

@@ -0,0 +1,98 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findNodes = exports.getRootTsConfigPath = exports.getRootTsConfigFileName = exports.resolveModuleByImport = exports.readTsConfig = void 0;
+const workspace_root_1 = require("../../../utils/workspace-root");
+const fs_1 = require("fs");
+const path_1 = require("path");
+const normalizedAppRoot = workspace_root_1.workspaceRoot.replace(/\\/g, '/');
+let tsModule;
+function readTsConfig(tsConfigPath) {
+    if (!tsModule) {
+        tsModule = require('typescript');
+    }
+    const readResult = tsModule.readConfigFile(tsConfigPath, tsModule.sys.readFile);
+    return tsModule.parseJsonConfigFileContent(readResult.config, tsModule.sys, (0, path_1.dirname)(tsConfigPath));
+}
+exports.readTsConfig = readTsConfig;
+function readTsConfigOptions(tsConfigPath) {
+    if (!tsModule) {
+        tsModule = require('typescript');
+    }
+    const readResult = tsModule.readConfigFile(tsConfigPath, tsModule.sys.readFile);
+    // we don't need to scan the files, we only care about options
+    const host = {
+        readDirectory: () => [],
+        readFile: () => '',
+        fileExists: tsModule.sys.fileExists,
+    };
+    return tsModule.parseJsonConfigFileContent(readResult.config, host, (0, path_1.dirname)(tsConfigPath)).options;
+}
+let compilerHost;
+/**
+ * Find a module based on its import
+ *
+ * @param importExpr Import used to resolve to a module
+ * @param filePath
+ * @param tsConfigPath
+ */
+function resolveModuleByImport(importExpr, filePath, tsConfigPath) {
+    compilerHost = compilerHost || getCompilerHost(tsConfigPath);
+    const { options, host, moduleResolutionCache } = compilerHost;
+    const { resolvedModule } = tsModule.resolveModuleName(importExpr, filePath, options, host, moduleResolutionCache);
+    if (!resolvedModule) {
+        return;
+    }
+    else {
+        return resolvedModule.resolvedFileName.replace(`${normalizedAppRoot}/`, '');
+    }
+}
+exports.resolveModuleByImport = resolveModuleByImport;
+function getCompilerHost(tsConfigPath) {
+    const options = readTsConfigOptions(tsConfigPath);
+    const host = tsModule.createCompilerHost(options, true);
+    const moduleResolutionCache = tsModule.createModuleResolutionCache(workspace_root_1.workspaceRoot, host.getCanonicalFileName);
+    return { options, host, moduleResolutionCache };
+}
+function getRootTsConfigFileName() {
+    for (const tsConfigName of ['tsconfig.base.json', 'tsconfig.json']) {
+        const tsConfigPath = (0, path_1.join)(workspace_root_1.workspaceRoot, tsConfigName);
+        if ((0, fs_1.existsSync)(tsConfigPath)) {
+            return tsConfigName;
+        }
+    }
+    return null;
+}
+exports.getRootTsConfigFileName = getRootTsConfigFileName;
+function getRootTsConfigPath() {
+    const tsConfigFileName = getRootTsConfigFileName();
+    return tsConfigFileName ? (0, path_1.join)(workspace_root_1.workspaceRoot, tsConfigFileName) : null;
+}
+exports.getRootTsConfigPath = getRootTsConfigPath;
+function findNodes(node, kind, max = Infinity) {
+    if (!node || max == 0) {
+        return [];
+    }
+    const arr = [];
+    const hasMatch = Array.isArray(kind)
+        ? kind.includes(node.kind)
+        : node.kind === kind;
+    if (hasMatch) {
+        arr.push(node);
+        max--;
+    }
+    if (max > 0) {
+        for (const child of node.getChildren()) {
+            findNodes(child, kind, max).forEach((node) => {
+                if (max > 0) {
+                    arr.push(node);
+                }
+                max--;
+            });
+            if (max <= 0) {
+                break;
+            }
+        }
+    }
+    return arr;
+}
+exports.findNodes = findNodes;

package/src/plugins/js/versions.d.ts

@@ -0,0 +1 @@
+export declare const typescriptVersion = "~5.3.2";

package/src/plugins/js/versions.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.typescriptVersion = void 0;
+exports.typescriptVersion = '~5.3.2';

package/src/plugins/package-json-workspaces/create-nodes.d.ts

@@ -0,0 +1,19 @@
+import { NxJsonConfiguration } from '../../config/nx-json';
+import { ProjectConfiguration } from '../../config/workspace-json-project-json';
+import { NxPluginV2 } from '../../utils/nx-plugin';
+import { PackageJson } from '../../utils/package-json';
+export declare function getNxPackageJsonWorkspacesPlugin(root: string): NxPluginV2;
+export declare function createNodeFromPackageJson(pkgJsonPath: string, root: string): {
+    projects: {
+        [x: string]: ProjectConfiguration & {
+            name: string;
+        };
+    };
+};
+export declare function buildProjectConfigurationFromPackageJson(packageJson: PackageJson, path: string, nxJson: NxJsonConfiguration): ProjectConfiguration & {
+    name: string;
+};
+/**
+ * Get the package.json globs from package manager workspaces
+ */
+export declare function getGlobPatternsFromPackageManagerWorkspaces(root: string, readJson?: <T extends Object>(path: string) => T): string[];

package/src/plugins/package-json-workspaces/create-nodes.js

@@ -0,0 +1,130 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getGlobPatternsFromPackageManagerWorkspaces = exports.buildProjectConfigurationFromPackageJson = exports.createNodeFromPackageJson = exports.getNxPackageJsonWorkspacesPlugin = void 0;
+const minimatch_1 = require("minimatch");
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const nx_json_1 = require("../../config/nx-json");
+const workspaces_1 = require("../../config/workspaces");
+const fileutils_1 = require("../../utils/fileutils");
+const globs_1 = require("../../utils/globs");
+const logger_1 = require("../../utils/logger");
+const output_1 = require("../../utils/output");
+const package_json_1 = require("../../utils/package-json");
+const path_1 = require("../../utils/path");
+function getNxPackageJsonWorkspacesPlugin(root) {
+    const readJson = (f) => (0, fileutils_1.readJsonFile)((0, node_path_1.join)(root, f));
+    const patterns = getGlobPatternsFromPackageManagerWorkspaces(root, readJson);
+    // If the user only specified a negative pattern, we should find all package.json
+    // files and only return those that don't match a negative pattern.
+    const negativePatterns = patterns.filter((p) => p.startsWith('!'));
+    let positivePatterns = patterns.filter((p) => !p.startsWith('!'));
+    if (
+    // There are some negative patterns
+    negativePatterns.length > 0 &&
+        // No positive patterns
+        (positivePatterns.length === 0 ||
+            // Or only a single positive pattern that is the default coming from root package
+            (positivePatterns.length === 1 && positivePatterns[0] === 'package.json'))) {
+        positivePatterns.push('**/package.json');
+    }
+    return {
+        name: 'nx/core/package-json-workspaces',
+        createNodes: [
+            (0, globs_1.combineGlobPatterns)(positivePatterns),
+            (p) => {
+                if (!negativePatterns.some((negative) => (0, minimatch_1.minimatch)(p, negative))) {
+                    return createNodeFromPackageJson(p, root);
+                }
+                // A negative pattern matched, so we should not create a node for this package.json
+                return {};
+            },
+        ],
+    };
+}
+exports.getNxPackageJsonWorkspacesPlugin = getNxPackageJsonWorkspacesPlugin;
+function createNodeFromPackageJson(pkgJsonPath, root) {
+    const json = (0, fileutils_1.readJsonFile)((0, node_path_1.join)(root, pkgJsonPath));
+    const project = buildProjectConfigurationFromPackageJson(json, pkgJsonPath, (0, nx_json_1.readNxJson)(root));
+    return {
+        projects: {
+            [project.root]: project,
+        },
+    };
+}
+exports.createNodeFromPackageJson = createNodeFromPackageJson;
+function buildProjectConfigurationFromPackageJson(packageJson, path, nxJson) {
+    const normalizedPath = path.split('\\').join('/');
+    const directory = (0, node_path_1.dirname)(normalizedPath);
+    if (!packageJson.name && directory === '.') {
+        throw new Error('Nx requires the root package.json to specify a name if it is being used as an Nx project.');
+    }
+    let name = packageJson.name ?? (0, workspaces_1.toProjectName)(normalizedPath);
+    const projectType = nxJson?.workspaceLayout?.appsDir != nxJson?.workspaceLayout?.libsDir &&
+        nxJson?.workspaceLayout?.appsDir &&
+        directory.startsWith(nxJson.workspaceLayout.appsDir)
+        ? 'application'
+        : 'library';
+    return {
+        root: directory,
+        sourceRoot: directory,
+        name,
+        projectType,
+        ...packageJson.nx,
+        targets: (0, package_json_1.readTargetsFromPackageJson)(packageJson),
+    };
+}
+exports.buildProjectConfigurationFromPackageJson = buildProjectConfigurationFromPackageJson;
+/**
+ * Get the package.json globs from package manager workspaces
+ */
+function getGlobPatternsFromPackageManagerWorkspaces(root, readJson = (path) => (0, fileutils_1.readJsonFile)((0, node_path_1.join)(root, path)) // making this an arg allows us to reuse in devkit
+) {
+    try {
+        const patterns = [];
+        const packageJson = readJson('package.json');
+        patterns.push(...normalizePatterns(Array.isArray(packageJson.workspaces)
+            ? packageJson.workspaces
+            : packageJson.workspaces?.packages ?? []));
+        if ((0, node_fs_1.existsSync)((0, node_path_1.join)(root, 'pnpm-workspace.yaml'))) {
+            try {
+                const { packages } = (0, fileutils_1.readYamlFile)((0, node_path_1.join)(root, 'pnpm-workspace.yaml'));
+                patterns.push(...normalizePatterns(packages || []));
+            }
+            catch (e) {
+                output_1.output.warn({
+                    title: `${logger_1.NX_PREFIX} Unable to parse pnpm-workspace.yaml`,
+                    bodyLines: [e.toString()],
+                });
+            }
+        }
+        if ((0, node_fs_1.existsSync)((0, node_path_1.join)(root, 'lerna.json'))) {
+            try {
+                const { packages } = readJson('lerna.json');
+                patterns.push(...normalizePatterns(packages?.length > 0 ? packages : ['packages/*']));
+            }
+            catch (e) {
+                output_1.output.warn({
+                    title: `${logger_1.NX_PREFIX} Unable to parse lerna.json`,
+                    bodyLines: [e.toString()],
+                });
+            }
+        }
+        // Merge patterns from workspaces definitions
+        // TODO(@AgentEnder): update logic after better way to determine root project inclusion
+        // Include the root project
+        return packageJson.nx ? patterns.concat('package.json') : patterns;
+    }
+    catch {
+        return [];
+    }
+}
+exports.getGlobPatternsFromPackageManagerWorkspaces = getGlobPatternsFromPackageManagerWorkspaces;
+function normalizePatterns(patterns) {
+    return patterns.map((pattern) => removeRelativePath(pattern.endsWith('/package.json')
+        ? pattern
+        : (0, path_1.joinPathFragments)(pattern, 'package.json')));
+}
+function removeRelativePath(pattern) {
+    return pattern.startsWith('./') ? pattern.substring(2) : pattern;
+}

package/src/plugins/package-json-workspaces/index.d.ts

@@ -0,0 +1 @@
+export * from './create-nodes';

package/src/plugins/package-json-workspaces/index.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./create-nodes"), exports);

package/src/plugins/project-json/build-nodes/package-json-next-to-project-json.d.ts

@@ -0,0 +1,2 @@
+import { NxPluginV2 } from '../../../utils/nx-plugin';
+export declare const PackageJsonProjectsNextToProjectJsonPlugin: NxPluginV2;

package/src/plugins/project-json/build-nodes/package-json-next-to-project-json.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PackageJsonProjectsNextToProjectJsonPlugin = void 0;
+const path_1 = require("path");
+const fs_1 = require("fs");
+const fileutils_1 = require("../../../utils/fileutils");
+const package_json_1 = require("../../../utils/package-json");
+// TODO: Remove this one day, this should not need to be done.
+exports.PackageJsonProjectsNextToProjectJsonPlugin = {
+    // Its not a problem if plugins happen to have same name, and this
+    // will look least confusing in the source map.
+    name: 'nx/core/package-json',
+    createNodes: [
+        '{project.json,**/project.json}',
+        (file, _, { workspaceRoot }) => {
+            const project = createProjectFromPackageJsonNextToProjectJson(file, workspaceRoot);
+            return project
+                ? {
+                    projects: {
+                        [project.name]: project,
+                    },
+                }
+                : {};
+        },
+    ],
+};
+function createProjectFromPackageJsonNextToProjectJson(projectJsonPath, workspaceRoot) {
+    const root = (0, path_1.dirname)(projectJsonPath);
+    const packageJsonPath = (0, path_1.join)(workspaceRoot, root, 'package.json');
+    if (!(0, fs_1.existsSync)(packageJsonPath)) {
+        return null;
+    }
+    try {
+        const packageJson = (0, fileutils_1.readJsonFile)(packageJsonPath);
+        let { nx, name } = packageJson;
+        return {
+            ...nx,
+            name,
+            root,
+            targets: (0, package_json_1.readTargetsFromPackageJson)(packageJson),
+        };
+    }
+    catch (e) {
+        console.log(e);
+        return null;
+    }
+}

package/src/plugins/project-json/build-nodes/project-json.d.ts

@@ -0,0 +1,4 @@
+import { ProjectConfiguration } from '../../../config/workspace-json-project-json';
+import { NxPluginV2 } from '../../../utils/nx-plugin';
+export declare const ProjectJsonProjectsPlugin: NxPluginV2;
+export declare function buildProjectFromProjectJson(json: Partial<ProjectConfiguration>, path: string): ProjectConfiguration;

package/src/plugins/project-json/build-nodes/project-json.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildProjectFromProjectJson = exports.ProjectJsonProjectsPlugin = void 0;
+const node_path_1 = require("node:path");
+const workspaces_1 = require("../../../config/workspaces");
+const fileutils_1 = require("../../../utils/fileutils");
+exports.ProjectJsonProjectsPlugin = {
+    name: 'nx/core/project-json',
+    createNodes: [
+        '{project.json,**/project.json}',
+        (file, _, { workspaceRoot }) => {
+            const json = (0, fileutils_1.readJsonFile)((0, node_path_1.join)(workspaceRoot, file));
+            const project = buildProjectFromProjectJson(json, file);
+            return {
+                projects: {
+                    [project.root]: project,
+                },
+            };
+        },
+    ],
+};
+function buildProjectFromProjectJson(json, path) {
+    return {
+        name: (0, workspaces_1.toProjectName)(path),
+        root: (0, node_path_1.dirname)(path),
+        ...json,
+    };
+}
+exports.buildProjectFromProjectJson = buildProjectFromProjectJson;

package/src/plugins/target-defaults/target-defaults-plugin.d.ts

@@ -0,0 +1,8 @@
+import { NxPluginV2 } from '../../utils/nx-plugin';
+/**
+ * This symbol marks that a target provides information which should modify a target already registered
+ * on the project via other plugins. If the target has not already been registered, and this symbol is true,
+ * the information provided by it will be discarded.
+ */
+export declare const ONLY_MODIFIES_EXISTING_TARGET: unique symbol;
+export declare const TargetDefaultsPlugin: NxPluginV2;