nx 18.1.0-canary.20240309-235ca8c → 18.1.0-canary.20240313-81df848

package/src/project-graph/plugins/worker-api.js

@@ -1,195 +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.loadNxPluginAsync = exports.loadPlugin = exports.loadPlugins = exports.getPluginPathAndName = exports.registerPluginTSTranspiler = exports.resolveLocalNxPlugin = exports.readPluginPackageJson = void 0;
-const posix_1 = require("node:path/posix");
-const installation_directory_1 = require("../../utils/installation-directory");
-const package_json_1 = require("../../utils/package-json");
-const fileutils_1 = require("../../utils/fileutils");
-const workspace_root_1 = require("../../utils/workspace-root");
-const node_fs_1 = require("node:fs");
-const typescript_1 = require("../../utils/typescript");
-const register_1 = require("../../plugins/js/utils/register");
-const find_project_for_path_1 = require("../utils/find-project-for-path");
-const path_1 = require("../../utils/path");
-const logger_1 = require("../../utils/logger");
-const node_path_1 = require("node:path");
-const path = require("node:path/posix");
-const retrieve_workspace_files_1 = require("../utils/retrieve-workspace-files");
-const utils_1 = require("./utils");
-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 = resolveLocalNxPlugin(pluginName, projects);
-            if (localPluginPath) {
-                const localPluginPackageJson = path.join(localPluginPath.path, 'package.json');
-                return {
-                    path: localPluginPackageJson,
-                    json: (0, fileutils_1.readJsonFile)(localPluginPackageJson),
-                };
-            }
-        }
-        throw e;
-    }
-}
-exports.readPluginPackageJson = readPluginPackageJson;
-function resolveLocalNxPlugin(importPath, projects, root = workspace_root_1.workspaceRoot) {
-    return lookupLocalPlugin(importPath, projects, root);
-}
-exports.resolveLocalNxPlugin = resolveLocalNxPlugin;
-/**
- * Register swc-node or ts-node if they are not currently registered
- * with some default settings which work well for Nx plugins.
- */
-function registerPluginTSTranspiler() {
-    // Get the first tsconfig that matches the allowed set
-    const tsConfigName = [
-        (0, posix_1.join)(workspace_root_1.workspaceRoot, 'tsconfig.base.json'),
-        (0, posix_1.join)(workspace_root_1.workspaceRoot, 'tsconfig.json'),
-    ].find((x) => (0, node_fs_1.existsSync)(x));
-    const tsConfig = tsConfigName
-        ? (0, typescript_1.readTsConfig)(tsConfigName)
-        : {};
-    (0, register_1.registerTsConfigPaths)(tsConfigName);
-    (0, register_1.registerTranspiler)({
-        experimentalDecorators: true,
-        emitDecoratorMetadata: true,
-        ...tsConfig.options,
-    });
-}
-exports.registerPluginTSTranspiler = registerPluginTSTranspiler;
-function lookupLocalPlugin(importPath, projects, root = workspace_root_1.workspaceRoot) {
-    const plugin = findNxProjectForImportPath(importPath, projects, root);
-    if (!plugin) {
-        return null;
-    }
-    const projectConfig = projects[plugin];
-    return { path: path.join(root, projectConfig.root), projectConfig };
-}
-function findNxProjectForImportPath(importPath, projects, root = workspace_root_1.workspaceRoot) {
-    const tsConfigPaths = readTsConfigPaths(root);
-    const possiblePaths = tsConfigPaths[importPath]?.map((p) => (0, path_1.normalizePath)(path.relative(root, path.join(root, p))));
-    if (possiblePaths?.length) {
-        const projectRootMappings = (0, find_project_for_path_1.createProjectRootMappingsFromProjectConfigurations)(projects);
-        for (const tsConfigPath of possiblePaths) {
-            const nxProject = (0, find_project_for_path_1.findProjectForPath)(tsConfigPath, projectRootMappings);
-            if (nxProject) {
-                return nxProject;
-            }
-        }
-        logger_1.logger.verbose('Unable to find local plugin', possiblePaths, projectRootMappings);
-        throw new Error('Unable to resolve local plugin with import path ' + importPath);
-    }
-}
-let tsconfigPaths;
-function readTsConfigPaths(root = workspace_root_1.workspaceRoot) {
-    if (!tsconfigPaths) {
-        const tsconfigPath = ['tsconfig.base.json', 'tsconfig.json']
-            .map((x) => path.join(root, x))
-            .filter((x) => (0, node_fs_1.existsSync)(x))[0];
-        if (!tsconfigPath) {
-            throw new Error('unable to find tsconfig.base.json or tsconfig.json');
-        }
-        const { compilerOptions } = (0, fileutils_1.readJsonFile)(tsconfigPath);
-        tsconfigPaths = compilerOptions?.paths;
-    }
-    return tsconfigPaths ?? {};
-}
-function readPluginMainFromProjectConfiguration(plugin) {
-    const { main } = Object.values(plugin.targets).find((x) => [
-        '@nx/js:tsc',
-        '@nrwl/js:tsc',
-        '@nx/js:swc',
-        '@nrwl/js:swc',
-        '@nx/node:package',
-        '@nrwl/node:package',
-    ].includes(x.executor))?.options ||
-        plugin.targets?.build?.options ||
-        {};
-    return main;
-}
-function getPluginPathAndName(moduleName, paths, projects, root) {
-    let pluginPath;
-    let registerTSTranspiler = false;
-    try {
-        pluginPath = require.resolve(moduleName, {
-            paths,
-        });
-        const extension = path.extname(pluginPath);
-        registerTSTranspiler = extension === '.ts';
-    }
-    catch (e) {
-        if (e.code === 'MODULE_NOT_FOUND') {
-            const plugin = resolveLocalNxPlugin(moduleName, projects, root);
-            if (plugin) {
-                registerTSTranspiler = true;
-                const main = readPluginMainFromProjectConfiguration(plugin.projectConfig);
-                pluginPath = main ? path.join(root, main) : plugin.path;
-            }
-            else {
-                logger_1.logger.error(`Plugin listed in \`nx.json\` not found: ${moduleName}`);
-                throw e;
-            }
-        }
-        else {
-            throw e;
-        }
-    }
-    const packageJsonPath = path.join(pluginPath, 'package.json');
-    // Register the ts-transpiler if we are pointing to a
-    // plain ts file that's not part of a plugin project
-    if (registerTSTranspiler) {
-        registerPluginTSTranspiler();
-    }
-    const { name } = !['.ts', '.js'].some((x) => (0, node_path_1.extname)(moduleName) === x) && // Not trying to point to a ts or js file
-        (0, node_fs_1.existsSync)(packageJsonPath) // plugin has a package.json
-        ? (0, fileutils_1.readJsonFile)(packageJsonPath) // read name from package.json
-        : { name: moduleName };
-    return { pluginPath, name };
-}
-exports.getPluginPathAndName = getPluginPathAndName;
-let projectsWithoutInference;
-async function loadPlugins(plugins, root) {
-    return await Promise.all(plugins.map((p) => loadPlugin(p, root)));
-}
-exports.loadPlugins = loadPlugins;
-async function loadPlugin(plugin, root) {
-    try {
-        require.resolve(typeof plugin === 'string' ? plugin : plugin.plugin);
-    }
-    catch {
-        // If a plugin cannot be resolved, we will need projects to resolve it
-        projectsWithoutInference ??=
-            await (0, retrieve_workspace_files_1.retrieveProjectConfigurationsWithoutPluginInference)(root);
-    }
-    return await loadNxPluginAsync(plugin, (0, installation_directory_1.getNxRequirePaths)(root), projectsWithoutInference, root);
-}
-exports.loadPlugin = loadPlugin;
-async function loadNxPluginAsync(pluginConfiguration, paths, projects, root) {
-    const { plugin: moduleName, options } = typeof pluginConfiguration === 'object'
-        ? pluginConfiguration
-        : { plugin: pluginConfiguration, options: undefined };
-    performance.mark(`Load Nx Plugin: ${moduleName} - start`);
-    let { pluginPath, name } = await getPluginPathAndName(moduleName, paths, projects, root);
-    const plugin = (0, utils_1.normalizeNxPlugin)(await importPluginModule(pluginPath));
-    plugin.name ??= name;
-    performance.mark(`Load Nx Plugin: ${moduleName} - end`);
-    performance.measure(`Load Nx Plugin: ${moduleName}`, `Load Nx Plugin: ${moduleName} - start`, `Load Nx Plugin: ${moduleName} - end`);
-    return { plugin, options };
-}
-exports.loadNxPluginAsync = loadNxPluginAsync;
-async function importPluginModule(pluginPath) {
-    const m = await Promise.resolve(`${pluginPath}`).then(s => require(s));
-    if (m.default &&
-        ('createNodes' in m.default || 'createDependencies' in m.default)) {
-        return m.default;
-    }
-    return m;
-}