nx 20.3.0-canary.20241212-0d1c960 → 20.3.0-canary.20241214-4cd640a

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nx",
-  "version": "20.3.0-canary.20241212-0d1c960",
+  "version": "20.3.0-canary.20241214-4cd640a",
   "private": false,
   "description": "The core Nx plugin contains the core functionality of Nx like the project graph, nx commands and task orchestration.",
   "repository": {
@@ -58,6 +58,7 @@
     "npm-run-path": "^4.0.1",
     "open": "^8.4.0",
     "ora": "5.3.0",
+    "resolve.exports": "2.0.3",
     "semver": "^7.5.3",
     "string-width": "^4.2.3",
     "tar-stream": "~2.2.0",
@@ -81,16 +82,16 @@
     }
   },
   "optionalDependencies": {
-    "@nx/nx-darwin-arm64": "20.3.0-canary.20241212-0d1c960",
-    "@nx/nx-darwin-x64": "20.3.0-canary.20241212-0d1c960",
-    "@nx/nx-freebsd-x64": "20.3.0-canary.20241212-0d1c960",
-    "@nx/nx-linux-arm-gnueabihf": "20.3.0-canary.20241212-0d1c960",
-    "@nx/nx-linux-arm64-gnu": "20.3.0-canary.20241212-0d1c960",
-    "@nx/nx-linux-arm64-musl": "20.3.0-canary.20241212-0d1c960",
-    "@nx/nx-linux-x64-gnu": "20.3.0-canary.20241212-0d1c960",
-    "@nx/nx-linux-x64-musl": "20.3.0-canary.20241212-0d1c960",
-    "@nx/nx-win32-arm64-msvc": "20.3.0-canary.20241212-0d1c960",
-    "@nx/nx-win32-x64-msvc": "20.3.0-canary.20241212-0d1c960"
+    "@nx/nx-darwin-arm64": "20.3.0-canary.20241214-4cd640a",
+    "@nx/nx-darwin-x64": "20.3.0-canary.20241214-4cd640a",
+    "@nx/nx-freebsd-x64": "20.3.0-canary.20241214-4cd640a",
+    "@nx/nx-linux-arm-gnueabihf": "20.3.0-canary.20241214-4cd640a",
+    "@nx/nx-linux-arm64-gnu": "20.3.0-canary.20241214-4cd640a",
+    "@nx/nx-linux-arm64-musl": "20.3.0-canary.20241214-4cd640a",
+    "@nx/nx-linux-x64-gnu": "20.3.0-canary.20241214-4cd640a",
+    "@nx/nx-linux-x64-musl": "20.3.0-canary.20241214-4cd640a",
+    "@nx/nx-win32-arm64-msvc": "20.3.0-canary.20241214-4cd640a",
+    "@nx/nx-win32-x64-msvc": "20.3.0-canary.20241214-4cd640a"
   },
   "nx-migrations": {
     "migrations": "./migrations.json",

package/src/adapter/ngcli-adapter.js

@@ -796,7 +796,7 @@ async function getWrappedWorkspaceNodeModulesArchitectHost(workspace, root, proj
                 builderName,
                 description: executorConfig.description,
                 optionSchema: builderInfo.schema,
-                import: (0, schema_utils_1.resolveImplementation)(executorConfig.implementation, (0, path_1.dirname)(executorsFilePath)),
+                import: (0, schema_utils_1.resolveImplementation)(executorConfig.implementation, (0, path_1.dirname)(executorsFilePath), packageName, this.projects),
             };
         }
         readExecutorsJson(nodeModule, builder, extraRequirePaths = []) {
@@ -825,14 +825,14 @@ async function getWrappedWorkspaceNodeModulesArchitectHost(workspace, root, proj
             try {
                 const { executorsFilePath, executorConfig, isNgCompat } = this.readExecutorsJson(nodeModule, executor);
                 const executorsDir = (0, path_1.dirname)(executorsFilePath);
-                const schemaPath = (0, schema_utils_1.resolveSchema)(executorConfig.schema, executorsDir);
+                const schemaPath = (0, schema_utils_1.resolveSchema)(executorConfig.schema, executorsDir, nodeModule, this.projects);
                 const schema = (0, executor_utils_1.normalizeExecutorSchema)((0, fileutils_1.readJsonFile)(schemaPath));
-                const implementationFactory = this.getImplementationFactory(executorConfig.implementation, executorsDir);
+                const implementationFactory = this.getImplementationFactory(executorConfig.implementation, executorsDir, nodeModule);
                 const batchImplementationFactory = executorConfig.batchImplementation
-                    ? this.getImplementationFactory(executorConfig.batchImplementation, executorsDir)
+                    ? this.getImplementationFactory(executorConfig.batchImplementation, executorsDir, nodeModule)
                     : null;
                 const hasherFactory = executorConfig.hasher
-                    ? this.getImplementationFactory(executorConfig.hasher, executorsDir)
+                    ? this.getImplementationFactory(executorConfig.hasher, executorsDir, nodeModule)
                     : null;
                 return {
                     schema,
@@ -846,8 +846,8 @@ async function getWrappedWorkspaceNodeModulesArchitectHost(workspace, root, proj
                 throw new Error(`Unable to resolve ${nodeModule}:${executor}.\n${e.message}`);
             }
         }
-        getImplementationFactory(implementation, executorsDir) {
-            return (0, schema_utils_1.getImplementationFactory)(implementation, executorsDir);
+        getImplementationFactory(implementation, executorsDir, packageName) {
+            return (0, schema_utils_1.getImplementationFactory)(implementation, executorsDir, packageName, this.projects);
         }
     }
     return new WrappedWorkspaceNodeModulesArchitectHost(workspace, root, projects);

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

@@ -13,14 +13,14 @@ function getGeneratorInformation(collectionName, generatorName, root, projects)
         const generatorConfig = generatorsJson.generators?.[normalizedGeneratorName] ||
             generatorsJson.schematics?.[normalizedGeneratorName];
         const isNgCompat = !generatorsJson.generators?.[normalizedGeneratorName];
-        const schemaPath = (0, schema_utils_1.resolveSchema)(generatorConfig.schema, generatorsDir);
+        const schemaPath = (0, schema_utils_1.resolveSchema)(generatorConfig.schema, generatorsDir, collectionName, projects);
         const schema = (0, fileutils_1.readJsonFile)(schemaPath);
         if (!schema.properties || typeof schema.properties !== 'object') {
             schema.properties = {};
         }
         generatorConfig.implementation =
             generatorConfig.implementation || generatorConfig.factory;
-        const implementationFactory = (0, schema_utils_1.getImplementationFactory)(generatorConfig.implementation, generatorsDir);
+        const implementationFactory = (0, schema_utils_1.getImplementationFactory)(generatorConfig.implementation, generatorsDir, collectionName, projects);
         const normalizedGeneratorConfiguration = {
             ...generatorConfig,
             aliases: generatorConfig.aliases ?? [],

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

@@ -29,14 +29,14 @@ function getExecutorInformation(nodeModule, executor, root, projects) {
             return cachedExecutorInformation[key];
         const { executorsFilePath, executorConfig, isNgCompat } = readExecutorJson(nodeModule, executor, root, projects);
         const executorsDir = (0, path_1.dirname)(executorsFilePath);
-        const schemaPath = (0, schema_utils_1.resolveSchema)(executorConfig.schema, executorsDir);
+        const schemaPath = (0, schema_utils_1.resolveSchema)(executorConfig.schema, executorsDir, nodeModule, projects);
         const schema = normalizeExecutorSchema((0, fileutils_1.readJsonFile)(schemaPath));
-        const implementationFactory = (0, schema_utils_1.getImplementationFactory)(executorConfig.implementation, executorsDir);
+        const implementationFactory = (0, schema_utils_1.getImplementationFactory)(executorConfig.implementation, executorsDir, nodeModule, projects);
         const batchImplementationFactory = executorConfig.batchImplementation
-            ? (0, schema_utils_1.getImplementationFactory)(executorConfig.batchImplementation, executorsDir)
+            ? (0, schema_utils_1.getImplementationFactory)(executorConfig.batchImplementation, executorsDir, nodeModule, projects)
             : null;
         const hasherFactory = executorConfig.hasher
-            ? (0, schema_utils_1.getImplementationFactory)(executorConfig.hasher, executorsDir)
+            ? (0, schema_utils_1.getImplementationFactory)(executorConfig.hasher, executorsDir, nodeModule, projects)
             : null;
         const res = {
             schema,

package/src/config/schema-utils.d.ts

@@ -1,15 +1,16 @@
+import type { ProjectConfiguration } from './workspace-json-project-json';
 /**
  * This function is used to get the implementation factory of an executor or generator.
  * @param implementation path to the implementation
  * @param directory path to the directory
  * @returns a function that returns the implementation
  */
-export declare function getImplementationFactory<T>(implementation: string, directory: string): () => T;
+export declare function getImplementationFactory<T>(implementation: string, directory: string, packageName: string, projects: Record<string, ProjectConfiguration>): () => T;
 /**
  * This function is used to resolve the implementation of an executor or generator.
  * @param implementationModulePath
  * @param directory
  * @returns path to the implementation
  */
-export declare function resolveImplementation(implementationModulePath: string, directory: string): string;
-export declare function resolveSchema(schemaPath: string, directory: string): string;
+export declare function resolveImplementation(implementationModulePath: string, directory: string, packageName: string, projects: Record<string, ProjectConfiguration>): string;
+export declare function resolveSchema(schemaPath: string, directory: string, packageName: string, projects: Record<string, ProjectConfiguration>): string;

package/src/config/schema-utils.js

@@ -5,17 +5,20 @@ exports.resolveImplementation = resolveImplementation;
 exports.resolveSchema = resolveSchema;
 const fs_1 = require("fs");
 const path_1 = require("path");
+const resolve_exports_1 = require("resolve.exports");
+const packages_1 = require("../plugins/js/utils/packages");
 const plugins_1 = require("../project-graph/plugins");
+const path_2 = require("../utils/path");
 /**
  * This function is used to get the implementation factory of an executor or generator.
  * @param implementation path to the implementation
  * @param directory path to the directory
  * @returns a function that returns the implementation
  */
-function getImplementationFactory(implementation, directory) {
+function getImplementationFactory(implementation, directory, packageName, projects) {
     const [implementationModulePath, implementationExportName] = implementation.split('#');
     return () => {
-        const modulePath = resolveImplementation(implementationModulePath, directory);
+        const modulePath = resolveImplementation(implementationModulePath, directory, packageName, projects);
         if ((0, path_1.extname)(modulePath) === '.ts') {
             (0, plugins_1.registerPluginTSTranspiler)();
         }
@@ -31,8 +34,19 @@ function getImplementationFactory(implementation, directory) {
  * @param directory
  * @returns path to the implementation
  */
-function resolveImplementation(implementationModulePath, directory) {
+function resolveImplementation(implementationModulePath, directory, packageName, projects) {
     const validImplementations = ['', '.js', '.ts'].map((x) => implementationModulePath + x);
+    if (!directory.includes('node_modules')) {
+        // It might be a local plugin where the implementation path points to the
+        // outputs which might not exist or can be stale. We prioritize finding
+        // the implementation from the source over the outputs.
+        for (const maybeImplementation of validImplementations) {
+            const maybeImplementationFromSource = tryResolveFromSource(maybeImplementation, directory, packageName, projects);
+            if (maybeImplementationFromSource) {
+                return maybeImplementationFromSource;
+            }
+        }
+    }
     for (const maybeImplementation of validImplementations) {
         const maybeImplementationPath = (0, path_1.join)(directory, maybeImplementation);
         if ((0, fs_1.existsSync)(maybeImplementationPath)) {
@@ -47,7 +61,16 @@ function resolveImplementation(implementationModulePath, directory) {
     }
     throw new Error(`Could not resolve "${implementationModulePath}" from "${directory}".`);
 }
-function resolveSchema(schemaPath, directory) {
+function resolveSchema(schemaPath, directory, packageName, projects) {
+    if (!directory.includes('node_modules')) {
+        // It might be a local plugin where the schema path points to the outputs
+        // which might not exist or can be stale. We prioritize finding the schema
+        // from the source over the outputs.
+        const schemaPathFromSource = tryResolveFromSource(schemaPath, directory, packageName, projects);
+        if (schemaPathFromSource) {
+            return schemaPathFromSource;
+        }
+    }
     const maybeSchemaPath = (0, path_1.join)(directory, schemaPath);
     if ((0, fs_1.existsSync)(maybeSchemaPath)) {
         return maybeSchemaPath;
@@ -56,3 +79,47 @@ function resolveSchema(schemaPath, directory) {
         paths: [directory],
     });
 }
+let packageEntryPointsToProjectMap;
+function tryResolveFromSource(path, directory, packageName, projects) {
+    packageEntryPointsToProjectMap ??=
+        (0, packages_1.getPackageEntryPointsToProjectMap)(projects);
+    const localProject = packageEntryPointsToProjectMap[packageName];
+    if (!localProject) {
+        // it doesn't match any of the package names from the local projects
+        return null;
+    }
+    try {
+        const fromExports = (0, resolve_exports_1.resolve)({
+            name: localProject.metadata.js.packageName,
+            exports: localProject.metadata.js.packageExports,
+        }, path, { conditions: ['development'] });
+        if (fromExports && fromExports.length) {
+            for (const exportPath of fromExports) {
+                if ((0, fs_1.existsSync)((0, path_1.join)(directory, exportPath))) {
+                    return (0, path_1.join)(directory, exportPath);
+                }
+            }
+        }
+    }
+    catch { }
+    /**
+     * Fall back to try to "guess" the source by checking the path in some common directories:
+     * - the root of the project
+     * - the src directory
+     * - the src/lib directory
+     */
+    const segments = (0, path_2.normalizePath)(path).replace(/^\.\//, '').split('/');
+    for (let i = 1; i < segments.length; i++) {
+        const possiblePaths = [
+            (0, path_1.join)(directory, ...segments.slice(i)),
+            (0, path_1.join)(directory, 'src', ...segments.slice(i)),
+            (0, path_1.join)(directory, 'src', 'lib', ...segments.slice(i)),
+        ];
+        for (const possiblePath of possiblePaths) {
+            if ((0, fs_1.existsSync)(possiblePath)) {
+                return possiblePath;
+            }
+        }
+    }
+    return null;
+}

package/src/config/workspace-json-project-json.d.ts

@@ -1,3 +1,4 @@
+import type { PackageJson } from '../utils/package-json';
 import type { NxJsonConfiguration, NxReleaseVersionConfiguration } from './nx-json';
 /**
  * @deprecated use ProjectsConfigurations or NxJsonConfiguration
@@ -122,6 +123,10 @@ export interface ProjectMetadata {
             }[];
         };
     };
+    js?: {
+        packageName: string;
+        packageExports: undefined | PackageJson['exports'];
+    };
 }
 export interface TargetMetadata {
     [k: string]: any;

package/src/plugins/js/project-graph/build-dependencies/explicit-package-json-dependencies.d.ts

@@ -1,4 +1,4 @@
-import { CreateDependenciesContext } from '../../../../project-graph/plugins';
-import { RawProjectGraphDependency } from '../../../../project-graph/project-graph-builder';
+import type { CreateDependenciesContext } from '../../../../project-graph/plugins';
+import { type RawProjectGraphDependency } from '../../../../project-graph/project-graph-builder';
 import { TargetProjectLocator } from './target-project-locator';
 export declare function buildExplicitPackageJsonDependencies(ctx: CreateDependenciesContext, targetProjectLocator: TargetProjectLocator): RawProjectGraphDependency[];

package/src/plugins/js/project-graph/build-dependencies/explicit-package-json-dependencies.js

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.buildExplicitPackageJsonDependencies = buildExplicitPackageJsonDependencies;
-const node_path_1 = require("node:path");
 const project_graph_1 = require("../../../../config/project-graph");
 const file_utils_1 = require("../../../../project-graph/file-utils");
 const project_graph_builder_1 = require("../../../../project-graph/project-graph-builder");
@@ -9,43 +8,30 @@ const json_1 = require("../../../../utils/json");
 const path_1 = require("../../../../utils/path");
 function buildExplicitPackageJsonDependencies(ctx, targetProjectLocator) {
     const res = [];
-    let packageNameMap = undefined;
     const nodes = Object.values(ctx.projects);
     Object.keys(ctx.filesToProcess.projectFileMap).forEach((source) => {
         Object.values(ctx.filesToProcess.projectFileMap[source]).forEach((f) => {
             if (isPackageJsonAtProjectRoot(nodes, f.file)) {
-                // we only create the package name map once and only if a package.json file changes
-                packageNameMap = packageNameMap || createPackageNameMap(ctx.projects);
-                processPackageJson(source, f.file, ctx, targetProjectLocator, res, packageNameMap);
+                processPackageJson(source, f.file, ctx, targetProjectLocator, res);
             }
         });
     });
     return res;
 }
-function createPackageNameMap(projects) {
-    const res = {};
-    for (let projectName of Object.keys(projects)) {
-        try {
-            const packageJson = (0, json_1.parseJson)((0, file_utils_1.defaultFileRead)((0, node_path_1.join)(projects[projectName].root, 'package.json')));
-            res[packageJson.name ?? projectName] = projectName;
-        }
-        catch (e) { }
-    }
-    return res;
-}
 function isPackageJsonAtProjectRoot(nodes, fileName) {
     return (fileName.endsWith('package.json') &&
         nodes.find((projectNode) => (0, path_1.joinPathFragments)(projectNode.root, 'package.json') === fileName));
 }
-function processPackageJson(sourceProject, fileName, ctx, targetProjectLocator, collectedDeps, packageNameMap) {
+function processPackageJson(sourceProject, fileName, ctx, targetProjectLocator, collectedDeps) {
     try {
         const deps = readDeps((0, json_1.parseJson)((0, file_utils_1.defaultFileRead)(fileName)));
         for (const d of Object.keys(deps)) {
-            // package.json refers to another project in the monorepo
-            if (packageNameMap[d]) {
+            const localProject = targetProjectLocator.findDependencyInWorkspaceProjects(d);
+            if (localProject) {
+                // package.json refers to another project in the monorepo
                 const dependency = {
                     source: sourceProject,
-                    target: packageNameMap[d],
+                    target: localProject,
                     sourceFile: fileName,
                     type: project_graph_1.DependencyType.static,
                 };

package/src/plugins/js/project-graph/build-dependencies/target-project-locator.d.ts

@@ -1,4 +1,4 @@
-import { ProjectGraphExternalNode, ProjectGraphProjectNode } from '../../../../config/project-graph';
+import type { ProjectGraphExternalNode, ProjectGraphProjectNode } from '../../../../config/project-graph';
 /**
  * The key is a combination of the package name and the workspace relative directory
  * containing the file importing it e.g. `lodash__packages/my-lib`, the value is the
@@ -15,6 +15,7 @@ export declare class TargetProjectLocator {
     private tsConfig;
     private paths;
     private typescriptResolutionCache;
+    private packageEntryPointsToProjectMap;
     constructor(nodes: Record<string, ProjectGraphProjectNode>, externalNodes?: Record<string, ProjectGraphExternalNode>, npmResolutionCache?: NpmResolutionCache);
     /**
      * Resolve any workspace or external project that matches the given import expression,
@@ -38,6 +39,7 @@ export declare class TargetProjectLocator {
      * @returns
      */
     findPaths(normalizedImportExpr: string): string[] | undefined;
+    findDependencyInWorkspaceProjects(dep: string): string | null;
     private resolveImportWithTypescript;
     private resolveImportWithRequire;
     private findProjectOfResolvedModule;

package/src/plugins/js/project-graph/build-dependencies/target-project-locator.js

@@ -7,10 +7,11 @@ const node_path_1 = require("node:path");
 const semver_1 = require("semver");
 const find_project_for_path_1 = require("../../../../project-graph/utils/find-project-for-path");
 const fileutils_1 = require("../../../../utils/fileutils");
+const get_package_name_from_import_path_1 = require("../../../../utils/get-package-name-from-import-path");
 const workspace_root_1 = require("../../../../utils/workspace-root");
+const packages_1 = require("../../utils/packages");
 const resolve_relative_to_dir_1 = require("../../utils/resolve-relative-to-dir");
 const typescript_1 = require("../../utils/typescript");
-const get_package_name_from_import_path_1 = require("../../../../utils/get-package-name-from-import-path");
 /**
  * Use a shared cache to avoid repeated npm package resolution work within the TargetProjectLocator.
  */
@@ -98,6 +99,12 @@ class TargetProjectLocator {
             return this.findProjectOfResolvedModule(resolvedModule);
         }
         catch { }
+        // fall back to see if it's a locally linked workspace project where the
+        // output might not exist yet
+        const localProject = this.findDependencyInWorkspaceProjects(importExpr);
+        if (localProject) {
+            return localProject;
+        }
         // nothing found, cache for later
         this.npmResolutionCache.set(importExpr, null);
         return null;
@@ -182,6 +189,10 @@ class TargetProjectLocator {
         }
         return undefined;
     }
+    findDependencyInWorkspaceProjects(dep) {
+        this.packageEntryPointsToProjectMap ??= (0, packages_1.getPackageEntryPointsToProjectMap)(this.nodes);
+        return this.packageEntryPointsToProjectMap[dep]?.name ?? null;
+    }
     resolveImportWithTypescript(normalizedImportExpr, filePath) {
         let resolvedModule;
         if (this.typescriptResolutionCache.has(normalizedImportExpr)) {

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

@@ -0,0 +1,3 @@
+import type { ProjectGraphProjectNode } from '../../../config/project-graph';
+import type { ProjectConfiguration } from '../../../config/workspace-json-project-json';
+export declare function getPackageEntryPointsToProjectMap<T extends ProjectGraphProjectNode | ProjectConfiguration>(projects: Record<string, T>): Record<string, T>;

package/src/plugins/js/utils/packages.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPackageEntryPointsToProjectMap = getPackageEntryPointsToProjectMap;
+const posix_1 = require("node:path/posix");
+function getPackageEntryPointsToProjectMap(projects) {
+    const result = {};
+    for (const project of Object.values(projects)) {
+        const metadata = 'data' in project ? project.data.metadata : project.metadata;
+        if (!metadata?.js) {
+            continue;
+        }
+        const { packageName, packageExports } = metadata.js;
+        if (!packageExports || typeof packageExports === 'string') {
+            // no `exports` or it points to a file, which would be the equivalent of
+            // an '.' export, in which case the package name is the entry point
+            result[packageName] = project;
+        }
+        else {
+            for (const entryPoint of Object.keys(packageExports)) {
+                result[(0, posix_1.join)(packageName, entryPoint)] = project;
+            }
+        }
+    }
+    return result;
+}

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

@@ -84,6 +84,12 @@ function createNodeFromPackageJson(pkgJsonPath, workspaceRoot, cache) {
     const hash = (0, file_hasher_1.hashObject)({
         ...json,
         root: projectRoot,
+        /**
+         * Increment this number to force processing the package.json again. Do it
+         * when the implementation of this plugin is changed and results in different
+         * results for the same package.json contents.
+         */
+        bust: 1,
     });
     const cached = cache[hash];
     if (cached) {

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

@@ -25,6 +25,7 @@ const error_types_1 = require("../error-types");
 const path = require("node:path/posix");
 const typescript_1 = require("../../plugins/js/utils/typescript");
 const load_resolved_plugin_1 = require("./load-resolved-plugin");
+const packages_1 = require("../../plugins/js/utils/packages");
 function readPluginPackageJson(pluginName, projects, paths = (0, installation_directory_1.getNxRequirePaths)()) {
     try {
         const result = (0, package_json_1.readModulePackageJsonWithoutFallbacks)(pluginName, paths);
@@ -89,26 +90,32 @@ function lookupLocalPlugin(importPath, projects, root = workspace_root_1.workspa
     }
     return { path: path.join(root, projectConfig.root), projectConfig };
 }
+let packageEntryPointsToProjectMap;
 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 = new Map();
+    const possibleTsPaths = tsConfigPaths[importPath]?.map((p) => (0, path_1.normalizePath)(path.relative(root, path.join(root, p)))) ?? [];
+    const projectRootMappings = new Map();
+    if (possibleTsPaths.length) {
         const projectNameMap = new Map();
         for (const projectRoot in projects) {
             const project = projects[projectRoot];
             projectRootMappings.set(project.root, project.name);
             projectNameMap.set(project.name, project);
         }
-        for (const tsConfigPath of possiblePaths) {
+        for (const tsConfigPath of possibleTsPaths) {
             const nxProject = (0, find_project_for_path_1.findProjectForPath)(tsConfigPath, projectRootMappings);
             if (nxProject) {
                 return projectNameMap.get(nxProject);
             }
         }
-        logger_1.logger.verbose('Unable to find local plugin', possiblePaths, projectRootMappings);
-        throw new Error('Unable to resolve local plugin with import path ' + importPath);
     }
+    packageEntryPointsToProjectMap ??=
+        (0, packages_1.getPackageEntryPointsToProjectMap)(projects);
+    if (packageEntryPointsToProjectMap[importPath]) {
+        return packageEntryPointsToProjectMap[importPath];
+    }
+    logger_1.logger.verbose('Unable to find local plugin', possibleTsPaths, projectRootMappings);
+    throw new Error('Unable to resolve local plugin with import path ' + importPath);
 }
 let tsconfigPaths;
 function readTsConfigPaths(root = workspace_root_1.workspaceRoot) {

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

@@ -35,6 +35,7 @@ export interface PackageJson {
         types?: string;
         require?: string;
         import?: string;
+        development?: string;
     }>;
     dependencies?: Record<string, string>;
     devDependencies?: Record<string, string>;

package/src/utils/package-json.js

@@ -58,13 +58,17 @@ function buildTargetFromScript(script, scripts = {}, packageManagerCommand) {
 }
 let packageManagerCommand;
 function getMetadataFromPackageJson(packageJson) {
-    const { scripts, nx, description } = packageJson ?? {};
+    const { scripts, nx, description, name, exports } = packageJson;
     const includedScripts = nx?.includedScripts || Object.keys(scripts ?? {});
     return {
         targetGroups: {
             ...(includedScripts.length ? { 'NPM Scripts': includedScripts } : {}),
         },
         description,
+        js: {
+            packageName: name,
+            packageExports: exports,
+        },
     };
 }
 function getTagsFromPackageJson(packageJson) {