@nx/devkit 0.0.0-pr-22179-271588f

package/src/utils/package-json.js

@@ -0,0 +1,375 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NX_VERSION = exports.ensurePackage = exports.removeDependenciesFromPackageJson = exports.addDependenciesToPackageJson = void 0;
+const child_process_1 = require("child_process");
+const module_1 = require("module");
+const semver_1 = require("semver");
+const install_packages_task_1 = require("../tasks/install-packages-task");
+const nx_1 = require("../../nx");
+const tmp_1 = require("tmp");
+const path_1 = require("path");
+const fs_1 = require("fs");
+const { readJson, updateJson, getPackageManagerCommand, workspaceRoot, detectPackageManager, createTempNpmDirectory, getPackageManagerVersion, } = (0, nx_1.requireNx)();
+const UNIDENTIFIED_VERSION = 'UNIDENTIFIED_VERSION';
+const NON_SEMVER_TAGS = {
+    '*': 2,
+    [UNIDENTIFIED_VERSION]: 2,
+    next: 1,
+    latest: 0,
+    previous: -1,
+    legacy: -2,
+};
+function filterExistingDependencies(dependencies, existingAltDependencies) {
+    if (!existingAltDependencies) {
+        return dependencies;
+    }
+    return Object.keys(dependencies ?? {})
+        .filter((d) => !existingAltDependencies[d])
+        .reduce((acc, d) => ({ ...acc, [d]: dependencies[d] }), {});
+}
+function cleanSemver(version) {
+    return (0, semver_1.clean)(version) ?? (0, semver_1.coerce)(version);
+}
+function isIncomingVersionGreater(incomingVersion, existingVersion) {
+    // if version is in the format of "latest", "next" or similar - keep it, otherwise try to parse it
+    const incomingVersionCompareBy = incomingVersion in NON_SEMVER_TAGS
+        ? incomingVersion
+        : cleanSemver(incomingVersion)?.toString() ?? UNIDENTIFIED_VERSION;
+    const existingVersionCompareBy = existingVersion in NON_SEMVER_TAGS
+        ? existingVersion
+        : cleanSemver(existingVersion)?.toString() ?? UNIDENTIFIED_VERSION;
+    if (incomingVersionCompareBy in NON_SEMVER_TAGS &&
+        existingVersionCompareBy in NON_SEMVER_TAGS) {
+        return (NON_SEMVER_TAGS[incomingVersionCompareBy] >
+            NON_SEMVER_TAGS[existingVersionCompareBy]);
+    }
+    if (incomingVersionCompareBy in NON_SEMVER_TAGS ||
+        existingVersionCompareBy in NON_SEMVER_TAGS) {
+        return true;
+    }
+    return (0, semver_1.gt)(cleanSemver(incomingVersion), cleanSemver(existingVersion));
+}
+function updateExistingAltDependenciesVersion(dependencies, existingAltDependencies) {
+    return Object.keys(existingAltDependencies || {})
+        .filter((d) => {
+        if (!dependencies[d]) {
+            return false;
+        }
+        const incomingVersion = dependencies[d];
+        const existingVersion = existingAltDependencies[d];
+        return isIncomingVersionGreater(incomingVersion, existingVersion);
+    })
+        .reduce((acc, d) => ({ ...acc, [d]: dependencies[d] }), {});
+}
+function updateExistingDependenciesVersion(dependencies, existingDependencies = {}) {
+    return Object.keys(dependencies)
+        .filter((d) => {
+        if (!existingDependencies[d]) {
+            return true;
+        }
+        const incomingVersion = dependencies[d];
+        const existingVersion = existingDependencies[d];
+        return isIncomingVersionGreater(incomingVersion, existingVersion);
+    })
+        .reduce((acc, d) => ({ ...acc, [d]: dependencies[d] }), {});
+}
+/**
+ * Add Dependencies and Dev Dependencies to package.json
+ *
+ * For example:
+ * ```typescript
+ * addDependenciesToPackageJson(tree, { react: 'latest' }, { jest: 'latest' })
+ * ```
+ * This will **add** `react` and `jest` to the dependencies and devDependencies sections of package.json respectively.
+ *
+ * @param tree Tree representing file system to modify
+ * @param dependencies Dependencies to be added to the dependencies section of package.json
+ * @param devDependencies Dependencies to be added to the devDependencies section of package.json
+ * @param packageJsonPath Path to package.json
+ * @param keepExistingVersions If true, prevents existing dependencies from being bumped to newer versions
+ * @returns Callback to install dependencies only if necessary, no-op otherwise
+ */
+function addDependenciesToPackageJson(tree, dependencies, devDependencies, packageJsonPath = 'package.json', keepExistingVersions) {
+    const currentPackageJson = readJson(tree, packageJsonPath);
+    /** Dependencies to install that are not met in dev dependencies */
+    let filteredDependencies = filterExistingDependencies(dependencies, currentPackageJson.devDependencies);
+    /** Dev dependencies to install that are not met in dependencies */
+    let filteredDevDependencies = filterExistingDependencies(devDependencies, currentPackageJson.dependencies);
+    // filtered dependencies should consist of:
+    // - dependencies of the same type that are not present
+    // by default, filtered dependencies also include these (unless keepExistingVersions is true):
+    // - dependencies of the same type that have greater version
+    // - specified dependencies of the other type that have greater version and are already installed as current type
+    filteredDependencies = {
+        ...updateExistingDependenciesVersion(filteredDependencies, currentPackageJson.dependencies),
+        ...updateExistingAltDependenciesVersion(devDependencies, currentPackageJson.dependencies),
+    };
+    filteredDevDependencies = {
+        ...updateExistingDependenciesVersion(filteredDevDependencies, currentPackageJson.devDependencies),
+        ...updateExistingAltDependenciesVersion(dependencies, currentPackageJson.devDependencies),
+    };
+    if (keepExistingVersions) {
+        filteredDependencies = removeExistingDependencies(filteredDependencies, currentPackageJson.dependencies);
+        filteredDevDependencies = removeExistingDependencies(filteredDevDependencies, currentPackageJson.devDependencies);
+    }
+    else {
+        filteredDependencies = removeLowerVersions(filteredDependencies, currentPackageJson.dependencies);
+        filteredDevDependencies = removeLowerVersions(filteredDevDependencies, currentPackageJson.devDependencies);
+    }
+    if (requiresAddingOfPackages(currentPackageJson, filteredDependencies, filteredDevDependencies)) {
+        updateJson(tree, packageJsonPath, (json) => {
+            json.dependencies = {
+                ...(json.dependencies || {}),
+                ...filteredDependencies,
+            };
+            json.devDependencies = {
+                ...(json.devDependencies || {}),
+                ...filteredDevDependencies,
+            };
+            json.dependencies = sortObjectByKeys(json.dependencies);
+            json.devDependencies = sortObjectByKeys(json.devDependencies);
+            return json;
+        });
+        return () => {
+            (0, install_packages_task_1.installPackagesTask)(tree);
+        };
+    }
+    return () => { };
+}
+exports.addDependenciesToPackageJson = addDependenciesToPackageJson;
+/**
+ * @returns The the incoming dependencies that are higher than the existing verions
+ **/
+function removeLowerVersions(incomingDeps, existingDeps) {
+    return Object.keys(incomingDeps).reduce((acc, d) => {
+        if (!existingDeps?.[d] ||
+            isIncomingVersionGreater(incomingDeps[d], existingDeps[d])) {
+            acc[d] = incomingDeps[d];
+        }
+        return acc;
+    }, {});
+}
+function removeExistingDependencies(incomingDeps, existingDeps) {
+    return Object.keys(incomingDeps).reduce((acc, d) => {
+        if (!existingDeps?.[d]) {
+            acc[d] = incomingDeps[d];
+        }
+        return acc;
+    }, {});
+}
+/**
+ * Remove Dependencies and Dev Dependencies from package.json
+ *
+ * For example:
+ * ```typescript
+ * removeDependenciesFromPackageJson(tree, ['react'], ['jest'])
+ * ```
+ * This will **remove** `react` and `jest` from the dependencies and devDependencies sections of package.json respectively.
+ *
+ * @param dependencies Dependencies to be removed from the dependencies section of package.json
+ * @param devDependencies Dependencies to be removed from the devDependencies section of package.json
+ * @returns Callback to uninstall dependencies only if necessary. undefined is returned if changes are not necessary.
+ */
+function removeDependenciesFromPackageJson(tree, dependencies, devDependencies, packageJsonPath = 'package.json') {
+    const currentPackageJson = readJson(tree, packageJsonPath);
+    if (requiresRemovingOfPackages(currentPackageJson, dependencies, devDependencies)) {
+        updateJson(tree, packageJsonPath, (json) => {
+            for (const dep of dependencies) {
+                delete json.dependencies[dep];
+            }
+            for (const devDep of devDependencies) {
+                delete json.devDependencies[devDep];
+            }
+            json.dependencies = sortObjectByKeys(json.dependencies);
+            json.devDependencies = sortObjectByKeys(json.devDependencies);
+            return json;
+        });
+    }
+    return () => {
+        (0, install_packages_task_1.installPackagesTask)(tree);
+    };
+}
+exports.removeDependenciesFromPackageJson = removeDependenciesFromPackageJson;
+function sortObjectByKeys(obj) {
+    if (!obj || typeof obj !== 'object' || Array.isArray(obj)) {
+        return obj;
+    }
+    return Object.keys(obj)
+        .sort()
+        .reduce((result, key) => {
+        return {
+            ...result,
+            [key]: obj[key],
+        };
+    }, {});
+}
+/**
+ * Verifies whether the given packageJson dependencies require an update
+ * given the deps & devDeps passed in
+ */
+function requiresAddingOfPackages(packageJsonFile, deps, devDeps) {
+    let needsDepsUpdate = false;
+    let needsDevDepsUpdate = false;
+    packageJsonFile.dependencies = packageJsonFile.dependencies || {};
+    packageJsonFile.devDependencies = packageJsonFile.devDependencies || {};
+    if (Object.keys(deps).length > 0) {
+        needsDepsUpdate = Object.keys(deps).some((entry) => {
+            const incomingVersion = deps[entry];
+            if (packageJsonFile.dependencies[entry]) {
+                const existingVersion = packageJsonFile.dependencies[entry];
+                return isIncomingVersionGreater(incomingVersion, existingVersion);
+            }
+            if (packageJsonFile.devDependencies[entry]) {
+                const existingVersion = packageJsonFile.devDependencies[entry];
+                return isIncomingVersionGreater(incomingVersion, existingVersion);
+            }
+            return true;
+        });
+    }
+    if (Object.keys(devDeps).length > 0) {
+        needsDevDepsUpdate = Object.keys(devDeps).some((entry) => {
+            const incomingVersion = devDeps[entry];
+            if (packageJsonFile.devDependencies[entry]) {
+                const existingVersion = packageJsonFile.devDependencies[entry];
+                return isIncomingVersionGreater(incomingVersion, existingVersion);
+            }
+            if (packageJsonFile.dependencies[entry]) {
+                const existingVersion = packageJsonFile.dependencies[entry];
+                return isIncomingVersionGreater(incomingVersion, existingVersion);
+            }
+            return true;
+        });
+    }
+    return needsDepsUpdate || needsDevDepsUpdate;
+}
+/**
+ * Verifies whether the given packageJson dependencies require an update
+ * given the deps & devDeps passed in
+ */
+function requiresRemovingOfPackages(packageJsonFile, deps, devDeps) {
+    let needsDepsUpdate = false;
+    let needsDevDepsUpdate = false;
+    packageJsonFile.dependencies = packageJsonFile.dependencies || {};
+    packageJsonFile.devDependencies = packageJsonFile.devDependencies || {};
+    if (deps.length > 0) {
+        needsDepsUpdate = deps.some((entry) => packageJsonFile.dependencies[entry]);
+    }
+    if (devDeps.length > 0) {
+        needsDevDepsUpdate = devDeps.some((entry) => packageJsonFile.devDependencies[entry]);
+    }
+    return needsDepsUpdate || needsDevDepsUpdate;
+}
+const packageMapCache = new Map();
+function ensurePackage(pkgOrTree, requiredVersionOrPackage, maybeRequiredVersion, _) {
+    let pkg;
+    let requiredVersion;
+    if (typeof pkgOrTree === 'string') {
+        pkg = pkgOrTree;
+        requiredVersion = requiredVersionOrPackage;
+    }
+    else {
+        // Old Signature
+        pkg = requiredVersionOrPackage;
+        requiredVersion = maybeRequiredVersion;
+    }
+    if (packageMapCache.has(pkg)) {
+        return packageMapCache.get(pkg);
+    }
+    try {
+        return require(pkg);
+    }
+    catch (e) {
+        if (e.code === 'ERR_REQUIRE_ESM') {
+            // The package is installed, but is an ESM package.
+            // The consumer of this function can import it as needed.
+            return null;
+        }
+        else if (e.code !== 'MODULE_NOT_FOUND') {
+            throw e;
+        }
+    }
+    if (process.env.NX_DRY_RUN && process.env.NX_DRY_RUN !== 'false') {
+        throw new Error('NOTE: This generator does not support --dry-run. If you are running this in Nx Console, it should execute fine once you hit the "Generate" button.\n');
+    }
+    const { dir: tempDir } = createTempNpmDirectory?.() ?? {
+        dir: (0, tmp_1.dirSync)().name,
+    };
+    console.log(`Fetching ${pkg}...`);
+    const packageManager = detectPackageManager();
+    const isVerbose = process.env.NX_VERBOSE_LOGGING === 'true';
+    generatePackageManagerFiles(tempDir, packageManager);
+    const preInstallCommand = getPackageManagerCommand(packageManager).preInstall;
+    if (preInstallCommand) {
+        // ensure package.json and repo in tmp folder is set to a proper package manager state
+        (0, child_process_1.execSync)(preInstallCommand, {
+            cwd: tempDir,
+            stdio: isVerbose ? 'inherit' : 'ignore',
+        });
+    }
+    let addCommand = getPackageManagerCommand(packageManager).addDev;
+    if (packageManager === 'pnpm') {
+        addCommand = 'pnpm add -D'; // we need to ensure that we are not using workspace command
+    }
+    (0, child_process_1.execSync)(`${addCommand} ${pkg}@${requiredVersion}`, {
+        cwd: tempDir,
+        stdio: isVerbose ? 'inherit' : 'ignore',
+    });
+    addToNodePath((0, path_1.join)(workspaceRoot, 'node_modules'));
+    addToNodePath((0, path_1.join)(tempDir, 'node_modules'));
+    // Re-initialize the added paths into require
+    module_1.Module._initPaths();
+    try {
+        const result = require(require.resolve(pkg, {
+            paths: [tempDir],
+        }));
+        packageMapCache.set(pkg, result);
+        return result;
+    }
+    catch (e) {
+        if (e.code === 'ERR_REQUIRE_ESM') {
+            // The package is installed, but is an ESM package.
+            // The consumer of this function can import it as needed.
+            packageMapCache.set(pkg, null);
+            return null;
+        }
+        throw e;
+    }
+}
+exports.ensurePackage = ensurePackage;
+/**
+ * Generates necessary files needed for the package manager to work
+ * and for the node_modules to be accessible.
+ */
+function generatePackageManagerFiles(root, packageManager = detectPackageManager()) {
+    const [pmMajor] = getPackageManagerVersion(packageManager).split('.');
+    switch (packageManager) {
+        case 'yarn':
+            if (+pmMajor >= 2) {
+                (0, fs_1.writeFileSync)((0, path_1.join)(root, '.yarnrc.yml'), 'nodeLinker: node-modules\nenableScripts: false');
+            }
+            break;
+    }
+}
+function addToNodePath(dir) {
+    // NODE_PATH is a delimited list of paths.
+    // The delimiter is different for windows.
+    const delimiter = require('os').platform() === 'win32' ? ';' : ':';
+    const paths = process.env.NODE_PATH
+        ? process.env.NODE_PATH.split(delimiter)
+        : [];
+    // The path is already in the node path
+    if (paths.includes(dir)) {
+        return;
+    }
+    // Add the tmp path
+    paths.push(dir);
+    // Update the env variable.
+    process.env.NODE_PATH = paths.join(delimiter);
+}
+function getPackageVersion(pkg) {
+    return require((0, path_1.join)(pkg, 'package.json')).version;
+}
+/**
+ * @description The version of Nx used by the workspace. Returns null if no version is found.
+ */
+exports.NX_VERSION = getPackageVersion('nx');

package/src/utils/replace-package.d.ts

@@ -0,0 +1,2 @@
+import type { Tree } from 'nx/src/generators/tree';
+export declare function replaceNrwlPackageWithNxPackage(tree: Tree, oldPackageName: string, newPackageName: string): void;

package/src/utils/replace-package.js

@@ -0,0 +1,125 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.replaceNrwlPackageWithNxPackage = void 0;
+const nx_1 = require("../../nx");
+const visit_not_ignored_files_1 = require("../generators/visit-not-ignored-files");
+const path_1 = require("path");
+const binary_extensions_1 = require("./binary-extensions");
+const { logger } = (0, nx_1.requireNx)();
+const { getProjects, updateProjectConfiguration, readNxJson, updateNxJson, updateJson, } = (0, nx_1.requireNx)();
+function replaceNrwlPackageWithNxPackage(tree, oldPackageName, newPackageName) {
+    replacePackageInDependencies(tree, oldPackageName, newPackageName);
+    replacePackageInProjectConfigurations(tree, oldPackageName, newPackageName);
+    replacePackageInNxJson(tree, oldPackageName, newPackageName);
+    replaceMentions(tree, oldPackageName, newPackageName);
+}
+exports.replaceNrwlPackageWithNxPackage = replaceNrwlPackageWithNxPackage;
+function replacePackageInDependencies(tree, oldPackageName, newPackageName) {
+    (0, visit_not_ignored_files_1.visitNotIgnoredFiles)(tree, '.', (path) => {
+        if ((0, path_1.basename)(path) !== 'package.json') {
+            return;
+        }
+        try {
+            updateJson(tree, path, (packageJson) => {
+                for (const deps of [
+                    packageJson.dependencies ?? {},
+                    packageJson.devDependencies ?? {},
+                    packageJson.peerDependencies ?? {},
+                    packageJson.optionalDependencies ?? {},
+                ]) {
+                    if (oldPackageName in deps) {
+                        deps[newPackageName] = deps[oldPackageName];
+                        delete deps[oldPackageName];
+                    }
+                }
+                return packageJson;
+            });
+        }
+        catch (e) {
+            console.warn(`Could not replace ${oldPackageName} with ${newPackageName} in ${path}.`);
+        }
+    });
+}
+function replacePackageInProjectConfigurations(tree, oldPackageName, newPackageName) {
+    const projects = getProjects(tree);
+    for (const [projectName, projectConfiguration] of projects) {
+        let needsUpdate = false;
+        for (const [targetName, targetConfig] of Object.entries(projectConfiguration.targets ?? {})) {
+            if (!targetConfig.executor) {
+                continue;
+            }
+            const [pkg, executorName] = targetConfig.executor.split(':');
+            if (pkg === oldPackageName) {
+                needsUpdate = true;
+                projectConfiguration.targets[targetName].executor =
+                    newPackageName + ':' + executorName;
+            }
+        }
+        for (const [collection, collectionDefaults] of Object.entries(projectConfiguration.generators ?? {})) {
+            if (collection === oldPackageName) {
+                needsUpdate = true;
+                projectConfiguration.generators[newPackageName] = collectionDefaults;
+                delete projectConfiguration.generators[collection];
+            }
+        }
+        if (needsUpdate) {
+            updateProjectConfiguration(tree, projectName, projectConfiguration);
+        }
+    }
+}
+function replacePackageInNxJson(tree, oldPackageName, newPackageName) {
+    if (!tree.exists('nx.json')) {
+        return;
+    }
+    const nxJson = readNxJson(tree);
+    let needsUpdate = false;
+    for (const [targetName, targetConfig] of Object.entries(nxJson.targetDefaults ?? {})) {
+        if (!targetConfig.executor) {
+            continue;
+        }
+        const [pkg, executorName] = targetConfig.executor.split(':');
+        if (pkg === oldPackageName) {
+            needsUpdate = true;
+            nxJson.targetDefaults[targetName].executor =
+                newPackageName + ':' + executorName;
+        }
+    }
+    for (const [collection, collectionDefaults] of Object.entries(nxJson.generators ?? {})) {
+        if (collection === oldPackageName) {
+            needsUpdate = true;
+            nxJson.generators[newPackageName] = collectionDefaults;
+            delete nxJson.generators[collection];
+        }
+    }
+    if (needsUpdate) {
+        updateNxJson(tree, nxJson);
+    }
+}
+function replaceMentions(tree, oldPackageName, newPackageName) {
+    (0, visit_not_ignored_files_1.visitNotIgnoredFiles)(tree, '.', (path) => {
+        if ((0, binary_extensions_1.isBinaryPath)(path)) {
+            return;
+        }
+        const ignoredFiles = [
+            'yarn.lock',
+            'package-lock.json',
+            'pnpm-lock.yaml',
+            'CHANGELOG.md',
+        ];
+        if (ignoredFiles.includes((0, path_1.basename)(path))) {
+            return;
+        }
+        try {
+            const contents = tree.read(path).toString();
+            if (!contents.includes(oldPackageName)) {
+                return;
+            }
+            tree.write(path, contents.replace(new RegExp(oldPackageName, 'g'), newPackageName));
+        }
+        catch {
+            // Its **probably** ok, contents can be null if the file is too large or
+            // there was an access exception.
+            logger.warn(`An error was thrown when trying to update ${path}. If you believe the migration should have updated it, be sure to review the file and open an issue.`);
+        }
+    });
+}

package/src/utils/replace-project-configuration-with-plugin.d.ts

@@ -0,0 +1,3 @@
+import type { Tree } from 'nx/src/generators/tree';
+import type { CreateNodes } from 'nx/src/utils/nx-plugin';
+export declare function replaceProjectConfigurationsWithPlugin<T = unknown>(tree: Tree, rootMappings: Map<string, string>, pluginPath: string, createNodes: CreateNodes<T>, pluginOptions: T): Promise<void>;

package/src/utils/replace-project-configuration-with-plugin.js

@@ -0,0 +1,136 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.replaceProjectConfigurationsWithPlugin = void 0;
+const nx_1 = require("../../nx");
+const { readNxJson, updateNxJson, glob, hashObject, findProjectForPath, readProjectConfiguration, updateProjectConfiguration, } = (0, nx_1.requireNx)();
+async function replaceProjectConfigurationsWithPlugin(tree, rootMappings, pluginPath, createNodes, pluginOptions) {
+    const nxJson = readNxJson(tree);
+    const hasPlugin = nxJson.plugins?.some((p) => typeof p === 'string' ? p === pluginPath : p.plugin === pluginPath);
+    if (hasPlugin) {
+        return;
+    }
+    nxJson.plugins ??= [];
+    nxJson.plugins.push({
+        plugin: pluginPath,
+        options: pluginOptions,
+    });
+    updateNxJson(tree, nxJson);
+    const [pluginGlob, createNodesFunction] = createNodes;
+    const configFiles = glob(tree, [pluginGlob]);
+    for (const configFile of configFiles) {
+        try {
+            const projectName = findProjectForPath(configFile, rootMappings);
+            const projectConfig = readProjectConfiguration(tree, projectName);
+            const nodes = await createNodesFunction(configFile, pluginOptions, {
+                workspaceRoot: tree.root,
+                nxJsonConfiguration: readNxJson(tree),
+            });
+            const node = nodes.projects[Object.keys(nodes.projects)[0]];
+            for (const [targetName, targetConfig] of Object.entries(node.targets)) {
+                const targetFromProjectConfig = projectConfig.targets[targetName];
+                if (targetFromProjectConfig?.executor !== targetConfig.executor) {
+                    continue;
+                }
+                const targetFromCreateNodes = node.targets[targetName];
+                removeConfigurationDefinedByPlugin(targetName, targetFromProjectConfig, targetFromCreateNodes, projectConfig);
+            }
+            updateProjectConfiguration(tree, projectName, projectConfig);
+        }
+        catch (e) {
+            console.error(e);
+        }
+    }
+}
+exports.replaceProjectConfigurationsWithPlugin = replaceProjectConfigurationsWithPlugin;
+function removeConfigurationDefinedByPlugin(targetName, targetFromProjectConfig, targetFromCreateNodes, projectConfig) {
+    // Executor
+    delete targetFromProjectConfig.executor;
+    // Default Configuration
+    if (targetFromProjectConfig.defaultConfiguration ===
+        targetFromCreateNodes.defaultConfiguration) {
+        delete targetFromProjectConfig.defaultConfiguration;
+    }
+    // Cache
+    if (targetFromProjectConfig.cache === targetFromCreateNodes.cache) {
+        delete targetFromProjectConfig.cache;
+    }
+    // Depends On
+    if (targetFromProjectConfig.dependsOn &&
+        shouldRemoveArrayProperty(targetFromProjectConfig.dependsOn, targetFromCreateNodes.dependsOn)) {
+        delete targetFromProjectConfig.dependsOn;
+    }
+    // Outputs
+    if (targetFromProjectConfig.outputs &&
+        shouldRemoveArrayProperty(targetFromProjectConfig.outputs, targetFromCreateNodes.outputs)) {
+        delete targetFromProjectConfig.outputs;
+    }
+    // Inputs
+    if (targetFromProjectConfig.inputs &&
+        shouldRemoveArrayProperty(targetFromProjectConfig.inputs, targetFromCreateNodes.inputs)) {
+        delete targetFromProjectConfig.inputs;
+    }
+    // Options
+    for (const [optionName, optionValue] of Object.entries(targetFromProjectConfig.options ?? {})) {
+        if (equals(targetFromCreateNodes.options[optionName], optionValue)) {
+            delete targetFromProjectConfig.options[optionName];
+        }
+    }
+    if (Object.keys(targetFromProjectConfig.options).length === 0) {
+        delete targetFromProjectConfig.options;
+    }
+    // Configurations
+    for (const [configName, configOptions] of Object.entries(targetFromProjectConfig.configurations ?? {})) {
+        for (const [optionName, optionValue] of Object.entries(configOptions)) {
+            if (targetFromCreateNodes.configurations?.[configName]?.[optionName] ===
+                optionValue) {
+                delete targetFromProjectConfig.configurations[configName][optionName];
+            }
+        }
+        if (Object.keys(configOptions).length === 0) {
+            delete targetFromProjectConfig.configurations[configName];
+        }
+    }
+    if (Object.keys(targetFromProjectConfig.configurations ?? {}).length === 0) {
+        delete targetFromProjectConfig.configurations;
+    }
+    if (Object.keys(targetFromProjectConfig).length === 0) {
+        delete projectConfig.targets[targetName];
+    }
+}
+function equals(a, b) {
+    if (Array.isArray(a) && Array.isArray(b)) {
+        return a.length === b.length && a.every((v, i) => v === b[i]);
+    }
+    if (typeof a === 'object' && typeof b === 'object') {
+        return hashObject(a) === hashObject(b);
+    }
+    return a === b;
+}
+function shouldRemoveArrayProperty(arrayValuesFromProjectConfiguration, arrayValuesFromCreateNodes) {
+    const setOfArrayValuesFromProjectConfiguration = new Set(arrayValuesFromProjectConfiguration);
+    loopThroughArrayValuesFromCreateNodes: for (const arrayValueFromCreateNodes of arrayValuesFromCreateNodes) {
+        if (typeof arrayValueFromCreateNodes === 'string') {
+            if (!setOfArrayValuesFromProjectConfiguration.has(arrayValueFromCreateNodes)) {
+                // If the inputs from the project configuration is missing an input from createNodes it was removed
+                return false;
+            }
+            else {
+                setOfArrayValuesFromProjectConfiguration.delete(arrayValueFromCreateNodes);
+            }
+        }
+        else {
+            for (const arrayValue of setOfArrayValuesFromProjectConfiguration.values()) {
+                if (typeof arrayValue !== 'string' &&
+                    hashObject(arrayValue) === hashObject(arrayValueFromCreateNodes)) {
+                    setOfArrayValuesFromProjectConfiguration.delete(arrayValue);
+                    // Continue the outer loop, breaking out of this loop
+                    continue loopThroughArrayValuesFromCreateNodes;
+                }
+            }
+            // If an input was not matched, that means the input was removed
+            return false;
+        }
+    }
+    // If there are still inputs in the project configuration, they have added additional inputs
+    return setOfArrayValuesFromProjectConfiguration.size === 0;
+}