nx 20.8.4 → 22.7.7

package/src/project-graph/nx-deps-cache.js

@@ -1,282 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.nxSourceMaps = exports.nxFileMap = exports.nxProjectGraph = void 0;
-exports.ensureCacheDirectory = ensureCacheDirectory;
-exports.readFileMapCache = readFileMapCache;
-exports.readProjectGraphCache = readProjectGraphCache;
-exports.readSourceMapsCache = readSourceMapsCache;
-exports.createProjectFileMapCache = createProjectFileMapCache;
-exports.writeCache = writeCache;
-exports.shouldRecomputeWholeGraph = shouldRecomputeWholeGraph;
-exports.extractCachedFileData = extractCachedFileData;
-const node_fs_1 = require("node:fs");
-const path_1 = require("path");
-const perf_hooks_1 = require("perf_hooks");
-const cache_directory_1 = require("../utils/cache-directory");
-const fileutils_1 = require("../utils/fileutils");
-const versions_1 = require("../utils/versions");
-const error_types_1 = require("./error-types");
-exports.nxProjectGraph = (0, path_1.join)(cache_directory_1.workspaceDataDirectory, 'project-graph.json');
-exports.nxFileMap = (0, path_1.join)(cache_directory_1.workspaceDataDirectory, 'file-map.json');
-exports.nxSourceMaps = (0, path_1.join)(cache_directory_1.workspaceDataDirectory, 'source-maps.json');
-function ensureCacheDirectory() {
-    try {
-        if (!(0, node_fs_1.existsSync)(cache_directory_1.workspaceDataDirectory)) {
-            (0, node_fs_1.mkdirSync)(cache_directory_1.workspaceDataDirectory, { recursive: true });
-        }
-    }
-    catch (e) {
-        /*
-         * @jeffbcross: Node JS docs recommend against checking for existence of directory immediately before creating it.
-         * Instead, just try to create the directory and handle the error.
-         *
-         * We ran into race conditions when running scripts concurrently, where multiple scripts were
-         * arriving here simultaneously, checking for directory existence, then trying to create the directory simultaneously.
-         *
-         * In this case, we're creating the directory. If the operation failed, we ensure that the directory
-         * exists before continuing (or raise an exception).
-         */
-        if (!(0, fileutils_1.directoryExists)(cache_directory_1.workspaceDataDirectory)) {
-            throw new Error(`Failed to create directory: ${cache_directory_1.workspaceDataDirectory}`);
-        }
-    }
-}
-function readFileMapCache() {
-    perf_hooks_1.performance.mark('read cache:start');
-    ensureCacheDirectory();
-    let data = null;
-    try {
-        if ((0, fileutils_1.fileExists)(exports.nxFileMap)) {
-            data = (0, fileutils_1.readJsonFile)(exports.nxFileMap);
-        }
-    }
-    catch (error) {
-        console.log(`Error reading '${exports.nxFileMap}'. Continue the process without the cache.`);
-        console.log(error);
-    }
-    perf_hooks_1.performance.mark('read cache:end');
-    perf_hooks_1.performance.measure('read cache', 'read cache:start', 'read cache:end');
-    return data ?? null;
-}
-function readProjectGraphCache(minimumComputedAt) {
-    perf_hooks_1.performance.mark('read project-graph:start');
-    ensureCacheDirectory();
-    try {
-        if ((0, fileutils_1.fileExists)(exports.nxProjectGraph)) {
-            const { computedAt, errors, ...projectGraphCache } = (0, fileutils_1.readJsonFile)(exports.nxProjectGraph);
-            if (minimumComputedAt &&
-                (!computedAt || computedAt < minimumComputedAt)) {
-                throw new error_types_1.StaleProjectGraphCacheError();
-            }
-            if (errors && errors.length > 0) {
-                if (!minimumComputedAt) {
-                    // If you didn't pass minimum computed at, we do not know if
-                    // the errors on the cached graph would be relevant to what you
-                    // are running. Prior to adding error handling here, the graph
-                    // would not have been written to the cache. As such, this matches
-                    // existing behavior of the public API.
-                    return null;
-                }
-                throw new error_types_1.ProjectGraphError(errors, projectGraphCache, readSourceMapsCache());
-            }
-            return projectGraphCache;
-        }
-        else {
-            return null;
-        }
-    }
-    catch (error) {
-        if (error instanceof error_types_1.StaleProjectGraphCacheError ||
-            error instanceof error_types_1.ProjectGraphError) {
-            throw error;
-        }
-        console.log(`Error reading '${exports.nxProjectGraph}'. Continue the process without the cache.`);
-        console.log(error);
-        return null;
-    }
-    finally {
-        perf_hooks_1.performance.mark('read project-graph:end');
-        perf_hooks_1.performance.measure('read cache', 'read project-graph:start', 'read project-graph:end');
-    }
-}
-function readSourceMapsCache() {
-    perf_hooks_1.performance.mark('read source-maps:start');
-    ensureCacheDirectory();
-    let data = null;
-    try {
-        if ((0, fileutils_1.fileExists)(exports.nxSourceMaps)) {
-            data = (0, fileutils_1.readJsonFile)(exports.nxSourceMaps);
-        }
-    }
-    catch (error) {
-        console.log(`Error reading '${exports.nxSourceMaps}'. Continue the process without the cache.`);
-        console.log(error);
-    }
-    perf_hooks_1.performance.mark('read source-maps:end');
-    perf_hooks_1.performance.measure('read cache', 'read source-maps:start', 'read source-maps:end');
-    return data ?? null;
-}
-function createProjectFileMapCache(nxJson, packageJsonDeps, fileMap, tsConfig) {
-    const nxJsonPlugins = getNxJsonPluginsData(nxJson, packageJsonDeps);
-    const newValue = {
-        version: '6.0',
-        nxVersion: versions_1.nxVersion,
-        // compilerOptions may not exist, especially for package-based repos
-        pathMappings: tsConfig?.compilerOptions?.paths || {},
-        nxJsonPlugins,
-        pluginsConfig: nxJson?.pluginsConfig,
-        fileMap,
-    };
-    return newValue;
-}
-function writeCache(cache, projectGraph, sourceMaps, errors) {
-    perf_hooks_1.performance.mark('write cache:start');
-    let retry = 1;
-    let done = false;
-    do {
-        // write first to a unique temporary filename and then do a
-        // rename of the file to the correct filename
-        // this is to avoid any problems with half-written files
-        // in case of crash and/or partially written files due
-        // to multiple parallel processes reading and writing this file
-        const unique = (Math.random().toString(16) + '0000000').slice(2, 10);
-        const tmpProjectGraphPath = `${exports.nxProjectGraph}~${unique}`;
-        const tmpFileMapPath = `${exports.nxFileMap}~${unique}`;
-        const tmpSourceMapPath = `${exports.nxSourceMaps}~${unique}`;
-        try {
-            (0, fileutils_1.writeJsonFile)(tmpProjectGraphPath, {
-                ...projectGraph,
-                errors,
-                computedAt: Date.now(),
-            });
-            (0, node_fs_1.renameSync)(tmpProjectGraphPath, exports.nxProjectGraph);
-            (0, fileutils_1.writeJsonFile)(tmpSourceMapPath, sourceMaps);
-            (0, node_fs_1.renameSync)(tmpSourceMapPath, exports.nxSourceMaps);
-            // only write the file map if there are no errors
-            // if there were errors, the errors make the filemap invalid
-            // TODO: We should be able to keep the valid part of the filemap if the errors being thrown told us which parts of the filemap were invalid
-            if (errors.length === 0) {
-                (0, fileutils_1.writeJsonFile)(tmpFileMapPath, cache);
-                (0, node_fs_1.renameSync)(tmpFileMapPath, exports.nxFileMap);
-            }
-            done = true;
-        }
-        catch (err) {
-            if (err instanceof Error) {
-                console.log(`ERROR (${retry}) when writing \n${err.message}\n${err.stack}`);
-            }
-            else {
-                console.log(`ERROR  (${retry}) unknown error when writing ${exports.nxProjectGraph} and ${exports.nxFileMap}`);
-            }
-            ++retry;
-        }
-    } while (!done && retry < 5);
-    perf_hooks_1.performance.mark('write cache:end');
-    perf_hooks_1.performance.measure('write cache', 'write cache:start', 'write cache:end');
-}
-function shouldRecomputeWholeGraph(cache, packageJsonDeps, projects, nxJson, tsConfig) {
-    if (cache.version !== '6.0') {
-        return true;
-    }
-    if (cache.nxVersion !== versions_1.nxVersion) {
-        return true;
-    }
-    // we have a cached project that is no longer present
-    const cachedNodes = Object.keys(cache.fileMap.projectFileMap);
-    if (cachedNodes.some((p) => projects[p] === undefined)) {
-        return true;
-    }
-    // a path mapping for an existing project has changed
-    if (Object.keys(cache.pathMappings).some((t) => {
-        const cached = cache.pathMappings && cache.pathMappings[t]
-            ? JSON.stringify(cache.pathMappings[t])
-            : undefined;
-        const notCached = tsConfig?.compilerOptions?.paths && tsConfig?.compilerOptions?.paths[t]
-            ? JSON.stringify(tsConfig.compilerOptions.paths[t])
-            : undefined;
-        return cached !== notCached;
-    })) {
-        return true;
-    }
-    // a new plugin has been added
-    if (JSON.stringify(getNxJsonPluginsData(nxJson, packageJsonDeps)) !==
-        JSON.stringify(cache.nxJsonPlugins)) {
-        return true;
-    }
-    if (JSON.stringify(nxJson?.pluginsConfig) !==
-        JSON.stringify(cache.pluginsConfig)) {
-        return true;
-    }
-    return false;
-}
-/*
-This can only be invoked when the list of projects is either the same
-or new projects have been added, so every project in the cache has a corresponding
-project in fileMap
-*/
-function extractCachedFileData(fileMap, c) {
-    const filesToProcess = {
-        nonProjectFiles: [],
-        projectFileMap: {},
-    };
-    const cachedFileData = {
-        nonProjectFiles: {},
-        projectFileMap: {},
-    };
-    const currentProjects = Object.keys(fileMap.projectFileMap).filter((name) => fileMap.projectFileMap[name].length > 0);
-    currentProjects.forEach((p) => {
-        processProjectNode(p, c.fileMap.projectFileMap, cachedFileData.projectFileMap, filesToProcess.projectFileMap, fileMap);
-    });
-    processNonProjectFiles(c.fileMap.nonProjectFiles, fileMap.nonProjectFiles, filesToProcess.nonProjectFiles, cachedFileData.nonProjectFiles);
-    return {
-        filesToProcess,
-        cachedFileData,
-    };
-}
-function processNonProjectFiles(cachedFiles, nonProjectFiles, filesToProcess, cachedFileData) {
-    const cachedHashMap = new Map(cachedFiles.map((f) => [f.file, f]));
-    for (const f of nonProjectFiles) {
-        const cachedFile = cachedHashMap.get(f.file);
-        if (!cachedFile || cachedFile.hash !== f.hash) {
-            filesToProcess.push(f);
-        }
-        else {
-            cachedFileData[f.file] = cachedFile;
-        }
-    }
-}
-function processProjectNode(projectName, cachedFileMap, cachedFileData, filesToProcess, { projectFileMap }) {
-    if (!cachedFileMap[projectName]) {
-        filesToProcess[projectName] = projectFileMap[projectName];
-        return;
-    }
-    const fileDataFromCache = {};
-    for (let f of cachedFileMap[projectName]) {
-        fileDataFromCache[f.file] = f;
-    }
-    if (!cachedFileData[projectName]) {
-        cachedFileData[projectName] = {};
-    }
-    for (let f of projectFileMap[projectName]) {
-        const fromCache = fileDataFromCache[f.file];
-        if (fromCache && fromCache.hash == f.hash) {
-            cachedFileData[projectName][f.file] = fromCache;
-        }
-        else {
-            if (!filesToProcess[projectName]) {
-                filesToProcess[projectName] = [];
-            }
-            filesToProcess[projectName].push(f);
-        }
-    }
-}
-function getNxJsonPluginsData(nxJson, packageJsonDeps) {
-    return (nxJson?.plugins || []).map((p) => {
-        const [plugin, options] = typeof p === 'string' ? [p] : [p.plugin, p.options];
-        return {
-            name: plugin,
-            version: packageJsonDeps[plugin],
-            options,
-        };
-    });
-}

package/src/project-graph/plugins/get-plugins.d.ts

@@ -1,4 +0,0 @@
-import type { LoadedNxPlugin } from './loaded-nx-plugin';
-export declare function getPlugins(root?: string): Promise<LoadedNxPlugin[]>;
-export declare function getOnlyDefaultPlugins(root?: string): Promise<LoadedNxPlugin[]>;
-export declare function cleanupPlugins(): void;

package/src/project-graph/plugins/get-plugins.js

@@ -1,144 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getPlugins = getPlugins;
-exports.getOnlyDefaultPlugins = getOnlyDefaultPlugins;
-exports.cleanupPlugins = cleanupPlugins;
-const node_path_1 = require("node:path");
-const angular_json_1 = require("../../adapter/angular-json");
-const nx_json_1 = require("../../config/nx-json");
-const file_hasher_1 = require("../../hasher/file-hasher");
-const workspace_root_1 = require("../../utils/workspace-root");
-const isolation_1 = require("./isolation");
-const in_process_loader_1 = require("./in-process-loader");
-const transpiler_1 = require("./transpiler");
-const enabled_1 = require("./isolation/enabled");
-/**
- * Stuff for specified NX Plugins.
- */
-let currentPluginsConfigurationHash;
-let loadedPlugins;
-let pendingPluginsPromise;
-let cleanup;
-async function getPlugins(root = workspace_root_1.workspaceRoot) {
-    const pluginsConfiguration = (0, nx_json_1.readNxJson)(root).plugins ?? [];
-    const pluginsConfigurationHash = (0, file_hasher_1.hashObject)(pluginsConfiguration);
-    // If the plugins configuration has not changed, reuse the current plugins
-    if (loadedPlugins &&
-        pluginsConfigurationHash === currentPluginsConfigurationHash) {
-        return loadedPlugins;
-    }
-    // Cleanup current plugins before loading new ones
-    if (cleanup) {
-        pendingPluginsPromise = undefined;
-        cleanup();
-    }
-    pendingPluginsPromise ??= loadSpecifiedNxPlugins(pluginsConfiguration, root);
-    currentPluginsConfigurationHash = pluginsConfigurationHash;
-    const [[result, cleanupFn], defaultPlugins] = await Promise.all([
-        pendingPluginsPromise,
-        getOnlyDefaultPlugins(root),
-    ]);
-    cleanup = cleanupFn;
-    loadedPlugins = result.concat(defaultPlugins);
-    return loadedPlugins;
-}
-/**
- * Stuff for default NX Plugins.
- */
-let loadedDefaultPlugins;
-let cleanupDefaultPlugins;
-let pendingDefaultPluginPromise;
-async function getOnlyDefaultPlugins(root = workspace_root_1.workspaceRoot) {
-    // If the plugins configuration has not changed, reuse the current plugins
-    if (loadedDefaultPlugins) {
-        return loadedPlugins;
-    }
-    // Cleanup current plugins before loading new ones
-    if (cleanupDefaultPlugins) {
-        pendingDefaultPluginPromise = undefined;
-        cleanupDefaultPlugins();
-    }
-    pendingDefaultPluginPromise ??= loadDefaultNxPlugins(workspace_root_1.workspaceRoot);
-    const [result, cleanupFn] = await pendingDefaultPluginPromise;
-    cleanupDefaultPlugins = cleanupFn;
-    loadedPlugins = result;
-    return result;
-}
-function cleanupPlugins() {
-    pendingPluginsPromise = undefined;
-    pendingDefaultPluginPromise = undefined;
-    cleanup?.();
-    cleanupDefaultPlugins?.();
-}
-/**
- * Stuff for generic loading
- */
-const loadingMethod = (0, enabled_1.isIsolationEnabled)()
-    ? isolation_1.loadNxPluginInIsolation
-    : in_process_loader_1.loadNxPlugin;
-async function loadDefaultNxPlugins(root = workspace_root_1.workspaceRoot) {
-    performance.mark('loadDefaultNxPlugins:start');
-    const plugins = getDefaultPlugins(root);
-    const cleanupFunctions = [];
-    const ret = [
-        await Promise.all(plugins.map(async (plugin) => {
-            performance.mark(`Load Nx Plugin: ${plugin} - start`);
-            const [loadedPluginPromise, cleanup] = await loadingMethod(plugin, root);
-            cleanupFunctions.push(cleanup);
-            const res = await loadedPluginPromise;
-            performance.mark(`Load Nx Plugin: ${plugin} - end`);
-            performance.measure(`Load Nx Plugin: ${plugin}`, `Load Nx Plugin: ${plugin} - start`, `Load Nx Plugin: ${plugin} - end`);
-            return res;
-        })),
-        () => {
-            for (const fn of cleanupFunctions) {
-                fn();
-            }
-            if ((0, transpiler_1.pluginTranspilerIsRegistered)()) {
-                (0, transpiler_1.cleanupPluginTSTranspiler)();
-            }
-        },
-    ];
-    performance.mark('loadDefaultNxPlugins:end');
-    performance.measure('loadDefaultNxPlugins', 'loadDefaultNxPlugins:start', 'loadDefaultNxPlugins:end');
-    return ret;
-}
-async function loadSpecifiedNxPlugins(plugins, root = workspace_root_1.workspaceRoot) {
-    performance.mark('loadSpecifiedNxPlugins:start');
-    plugins ??= [];
-    const cleanupFunctions = [];
-    const ret = [
-        await Promise.all(plugins.map(async (plugin, index) => {
-            const pluginPath = typeof plugin === 'string' ? plugin : plugin.plugin;
-            performance.mark(`Load Nx Plugin: ${pluginPath} - start`);
-            const [loadedPluginPromise, cleanup] = await loadingMethod(plugin, root);
-            cleanupFunctions.push(cleanup);
-            const res = await loadedPluginPromise;
-            res.index = index;
-            performance.mark(`Load Nx Plugin: ${pluginPath} - end`);
-            performance.measure(`Load Nx Plugin: ${pluginPath}`, `Load Nx Plugin: ${pluginPath} - start`, `Load Nx Plugin: ${pluginPath} - end`);
-            return res;
-        })),
-        () => {
-            for (const fn of cleanupFunctions) {
-                fn();
-            }
-            if ((0, transpiler_1.pluginTranspilerIsRegistered)()) {
-                (0, transpiler_1.cleanupPluginTSTranspiler)();
-            }
-        },
-    ];
-    performance.mark('loadSpecifiedNxPlugins:end');
-    performance.measure('loadSpecifiedNxPlugins', 'loadSpecifiedNxPlugins:start', 'loadSpecifiedNxPlugins:end');
-    return ret;
-}
-function getDefaultPlugins(root) {
-    return [
-        (0, node_path_1.join)(__dirname, '../../plugins/js'),
-        ...((0, angular_json_1.shouldMergeAngularProjects)(root, false)
-            ? [(0, node_path_1.join)(__dirname, '../../adapter/angular-json')]
-            : []),
-        (0, node_path_1.join)(__dirname, '../../plugins/package-json'),
-        (0, node_path_1.join)(__dirname, '../../plugins/project-json/build-nodes/project-json'),
-    ];
-}

package/src/project-graph/plugins/in-process-loader.d.ts

@@ -1,10 +0,0 @@
-import { ProjectConfiguration } from '../../config/workspace-json-project-json';
-import { PackageJson } from '../../utils/package-json';
-import type { PluginConfiguration } from '../../config/nx-json';
-import type { LoadedNxPlugin } from './loaded-nx-plugin';
-export declare function readPluginPackageJson(pluginName: string, projects: Record<string, ProjectConfiguration>, paths?: string[]): {
-    path: string;
-    json: PackageJson;
-};
-export declare function loadNxPlugin(plugin: PluginConfiguration, root: string): readonly [Promise<LoadedNxPlugin>, () => void];
-export declare function loadNxPluginAsync(pluginConfiguration: PluginConfiguration, paths: string[], root: string): Promise<LoadedNxPlugin>;

package/src/project-graph/plugins/in-process-loader.js

@@ -1,60 +0,0 @@
-"use strict";
-// This file contains methods and utilities that should **only** be used by the plugin worker.
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.readPluginPackageJson = readPluginPackageJson;
-exports.loadNxPlugin = loadNxPlugin;
-exports.loadNxPluginAsync = loadNxPluginAsync;
-const installation_directory_1 = require("../../utils/installation-directory");
-const package_json_1 = require("../../utils/package-json");
-const fileutils_1 = require("../../utils/fileutils");
-const error_types_1 = require("../error-types");
-const path = require("node:path/posix");
-const load_resolved_plugin_1 = require("./load-resolved-plugin");
-const resolve_plugin_1 = require("./resolve-plugin");
-const transpiler_1 = require("./transpiler");
-function readPluginPackageJson(pluginName, projects, paths = (0, installation_directory_1.getNxRequirePaths)()) {
-    try {
-        const result = (0, package_json_1.readModulePackageJsonWithoutFallbacks)(pluginName, paths);
-        return {
-            json: result.packageJson,
-            path: result.path,
-        };
-    }
-    catch (e) {
-        if (e.code === 'MODULE_NOT_FOUND') {
-            const localPluginPath = (0, resolve_plugin_1.resolveLocalNxPlugin)(pluginName, projects);
-            if (localPluginPath) {
-                const localPluginPackageJson = path.join(localPluginPath.path, 'package.json');
-                if (!(0, transpiler_1.pluginTranspilerIsRegistered)()) {
-                    (0, transpiler_1.registerPluginTSTranspiler)();
-                }
-                return {
-                    path: localPluginPackageJson,
-                    json: (0, fileutils_1.readJsonFile)(localPluginPackageJson),
-                };
-            }
-        }
-        throw e;
-    }
-}
-function loadNxPlugin(plugin, root) {
-    return [
-        loadNxPluginAsync(plugin, (0, installation_directory_1.getNxRequirePaths)(root), root),
-        () => { },
-    ];
-}
-async function loadNxPluginAsync(pluginConfiguration, paths, root) {
-    const moduleName = typeof pluginConfiguration === 'string'
-        ? pluginConfiguration
-        : pluginConfiguration.plugin;
-    try {
-        const { pluginPath, name, shouldRegisterTSTranspiler } = await (0, resolve_plugin_1.resolveNxPlugin)(moduleName, root, paths);
-        if (shouldRegisterTSTranspiler) {
-            (0, transpiler_1.registerPluginTSTranspiler)();
-        }
-        return (0, load_resolved_plugin_1.loadResolvedNxPluginAsync)(pluginConfiguration, pluginPath, name);
-    }
-    catch (e) {
-        throw new error_types_1.LoadPluginError(moduleName, e);
-    }
-}

package/src/project-graph/plugins/isolation/enabled.js

@@ -1,19 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isIsolationEnabled = isIsolationEnabled;
-const native_1 = require("../../../native");
-function isIsolationEnabled() {
-    // Explicitly enabled, regardless of further conditions
-    if (process.env.NX_ISOLATE_PLUGINS === 'true') {
-        return true;
-    }
-    if (
-    // Explicitly disabled
-    process.env.NX_ISOLATE_PLUGINS === 'false' ||
-        // Isolation is disabled on WASM builds currently.
-        native_1.IS_WASM) {
-        return false;
-    }
-    // Default value
-    return true;
-}

package/src/project-graph/plugins/isolation/index.d.ts

@@ -1,3 +0,0 @@
-import type { PluginConfiguration } from '../../../config/nx-json';
-import type { LoadedNxPlugin } from '../loaded-nx-plugin';
-export declare function loadNxPluginInIsolation(plugin: PluginConfiguration, root?: string): Promise<readonly [Promise<LoadedNxPlugin>, () => void]>;

package/src/project-graph/plugins/isolation/index.js

@@ -1,8 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.loadNxPluginInIsolation = loadNxPluginInIsolation;
-const workspace_root_1 = require("../../../utils/workspace-root");
-const plugin_pool_1 = require("./plugin-pool");
-async function loadNxPluginInIsolation(plugin, root = workspace_root_1.workspaceRoot) {
-    return (0, plugin_pool_1.loadRemoteNxPlugin)(plugin, root);
-}

package/src/project-graph/plugins/isolation/messaging.d.ts

@@ -1,143 +0,0 @@
-import type { ProjectGraph } from '../../../config/project-graph';
-import type { PluginConfiguration } from '../../../config/nx-json';
-import type { CreateDependenciesContext, CreateMetadataContext, CreateNodesContextV2, PreTasksExecutionContext, PostTasksExecutionContext } from '../public-api';
-import type { LoadedNxPlugin } from '../loaded-nx-plugin';
-import type { Serializable } from 'child_process';
-import type { Socket } from 'net';
-export interface PluginWorkerLoadMessage {
-    type: 'load';
-    payload: {
-        plugin: PluginConfiguration;
-        root: string;
-        name: string;
-        pluginPath: string;
-        shouldRegisterTSTranspiler: boolean;
-    };
-}
-export interface PluginWorkerLoadResult {
-    type: 'load-result';
-    payload: {
-        name: string;
-        include?: string[];
-        exclude?: string[];
-        createNodesPattern: string;
-        hasCreateDependencies: boolean;
-        hasProcessProjectGraph: boolean;
-        hasCreateMetadata: boolean;
-        hasPreTasksExecution: boolean;
-        hasPostTasksExecution: boolean;
-        success: true;
-    } | {
-        success: false;
-        error: Error;
-    };
-}
-export interface PluginWorkerCreateNodesMessage {
-    type: 'createNodes';
-    payload: {
-        configFiles: string[];
-        context: CreateNodesContextV2;
-        tx: string;
-    };
-}
-export interface PluginWorkerCreateNodesResult {
-    type: 'createNodesResult';
-    payload: {
-        success: true;
-        result: Awaited<ReturnType<LoadedNxPlugin['createNodes'][1]>>;
-        tx: string;
-    } | {
-        success: false;
-        error: Error;
-        tx: string;
-    };
-}
-export interface PluginCreateDependenciesMessage {
-    type: 'createDependencies';
-    payload: {
-        context: CreateDependenciesContext;
-        tx: string;
-    };
-}
-export interface PluginCreateMetadataMessage {
-    type: 'createMetadata';
-    payload: {
-        graph: ProjectGraph;
-        context: CreateMetadataContext;
-        tx: string;
-    };
-}
-export interface PluginCreateDependenciesResult {
-    type: 'createDependenciesResult';
-    payload: {
-        dependencies: Awaited<ReturnType<LoadedNxPlugin['createDependencies']>>;
-        success: true;
-        tx: string;
-    } | {
-        success: false;
-        error: Error;
-        tx: string;
-    };
-}
-export interface PluginCreateMetadataResult {
-    type: 'createMetadataResult';
-    payload: {
-        metadata: Awaited<ReturnType<LoadedNxPlugin['createMetadata']>>;
-        success: true;
-        tx: string;
-    } | {
-        success: false;
-        error: Error;
-        tx: string;
-    };
-}
-export interface PluginWorkerPreTasksExecutionMessage {
-    type: 'preTasksExecution';
-    payload: {
-        tx: string;
-        context: PreTasksExecutionContext;
-    };
-}
-export interface PluginWorkerPreTasksExecutionMessageResult {
-    type: 'preTasksExecutionResult';
-    payload: {
-        tx: string;
-        success: true;
-        mutations: NodeJS.ProcessEnv;
-    } | {
-        success: false;
-        error: Error;
-        tx: string;
-    };
-}
-export interface PluginWorkerPostTasksExecutionMessage {
-    type: 'postTasksExecution';
-    payload: {
-        tx: string;
-        context: PostTasksExecutionContext;
-    };
-}
-export interface PluginWorkerPostTasksExecutionMessageResult {
-    type: 'postTasksExecutionResult';
-    payload: {
-        tx: string;
-        success: true;
-    } | {
-        success: false;
-        error: Error;
-        tx: string;
-    };
-}
-export type PluginWorkerMessage = PluginWorkerLoadMessage | PluginWorkerCreateNodesMessage | PluginCreateDependenciesMessage | PluginCreateMetadataMessage | PluginWorkerPreTasksExecutionMessage | PluginWorkerPostTasksExecutionMessage;
-export type PluginWorkerResult = PluginWorkerLoadResult | PluginWorkerCreateNodesResult | PluginCreateDependenciesResult | PluginCreateMetadataResult | PluginWorkerPreTasksExecutionMessageResult | PluginWorkerPostTasksExecutionMessageResult;
-export declare function isPluginWorkerMessage(message: Serializable): message is PluginWorkerMessage;
-export declare function isPluginWorkerResult(message: Serializable): message is PluginWorkerResult;
-type MaybePromise<T> = T | Promise<T>;
-type MessageHandlerReturn<T extends PluginWorkerMessage | PluginWorkerResult> = T extends PluginWorkerResult ? MaybePromise<PluginWorkerMessage | void> : MaybePromise<PluginWorkerResult | void>;
-export declare function consumeMessage<T extends PluginWorkerMessage | PluginWorkerResult>(socket: Socket, raw: T, handlers: {
-    [K in T['type']]: (payload: Extract<T, {
-        type: K;
-    }>['payload']) => MessageHandlerReturn<T>;
-}): Promise<void>;
-export declare function sendMessageOverSocket(socket: Socket, message: PluginWorkerMessage | PluginWorkerResult): void;
-export {};