@nx/eslint-plugin 20.8.0 → 20.8.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nx/eslint-plugin",
-  "version": "20.8.0",
+  "version": "20.8.2",
   "private": false,
   "description": "The eslint-plugin package is an ESLint plugin that contains a collection of recommended ESLint rule configurations which you can extend from in your own ESLint configs, as well as an Nx-specific lint rule called enforce-module-boundaries.",
   "repository": {
@@ -34,8 +34,8 @@
     }
   },
   "dependencies": {
-    "@nx/devkit": "20.8.0",
-    "@nx/js": "20.8.0",
+    "@nx/devkit": "20.8.2",
+    "@nx/js": "20.8.2",
     "@typescript-eslint/type-utils": "^8.0.0",
     "@typescript-eslint/utils": "^8.0.0",
     "chalk": "^4.1.0",

package/src/flat-configs/typescript.js

@@ -27,7 +27,7 @@ exports.default = typescript_eslint_1.default.config({
         },
     },
 }, {
-    files: ['**/*.ts', '**/*.tsx', , '**/*.cts', '**/*.mts'],
+    files: ['**/*.ts', '**/*.tsx', '**/*.cts', '**/*.mts'],
     rules: {
         '@typescript-eslint/explicit-member-accessibility': 'off',
         '@typescript-eslint/explicit-module-boundary-types': 'off',

package/src/rules/enforce-module-boundaries.js

@@ -251,7 +251,7 @@ exports.default = utils_1.ESLintUtils.RuleCreator(() => `https://github.com/nrwl
                 !(0, graph_utils_1.circularPathHasPair)([sourceProject, targetProject], expandedIgnoreCircularDependencies)) {
                 if (!allowCircularSelfDependency &&
                     !(0, fileutils_1.isRelativePath)(imp) &&
-                    !(0, runtime_lint_utils_1.belongsToDifferentNgEntryPoint)(imp, sourceFilePath, sourceProject.data.root)) {
+                    !(0, runtime_lint_utils_1.belongsToDifferentEntryPoint)(imp, sourceFilePath, sourceProject.data.root)) {
                     context.report({
                         node,
                         messageId: 'noSelfCircularDependencies',
@@ -391,7 +391,7 @@ exports.default = utils_1.ESLintUtils.RuleCreator(() => `https://github.com/nrwl
             }
             // if we import a library using loadChildren, we should not import it using es6imports
             if (!checkDynamicDependenciesExceptions.some((a) => (0, runtime_lint_utils_1.matchImportWithWildcard)(a, imp)) &&
-                (0, runtime_lint_utils_1.hasStaticImportOfDynamicResource)(node, projectGraph, sourceProject.name, targetProject.name)) {
+                (0, runtime_lint_utils_1.hasStaticImportOfDynamicResource)(node, projectGraph, sourceProject.name, targetProject.name, imp, sourceFilePath)) {
                 const filesWithLazyImports = (0, graph_utils_1.findFilesWithDynamicImports)(projectFileMap, sourceProject.name, targetProject.name);
                 context.report({
                     data: {

package/src/utils/runtime-lint-utils.d.ts

@@ -40,7 +40,7 @@ export declare function isAbsoluteImportIntoAnotherProject(imp: string, workspac
 }): boolean;
 export declare function findProjectUsingImport(projectGraph: ProjectGraph, targetProjectLocator: TargetProjectLocator, filePath: string, imp: string): ProjectGraphProjectNode | ProjectGraphExternalNode;
 export declare function findConstraintsFor(depConstraints: DepConstraint[], sourceProject: ProjectGraphProjectNode): DepConstraint[];
-export declare function hasStaticImportOfDynamicResource(node: TSESTree.ImportDeclaration | TSESTree.ImportExpression | TSESTree.ExportAllDeclaration | TSESTree.ExportNamedDeclaration, graph: ProjectGraph, sourceProjectName: string, targetProjectName: string): boolean;
+export declare function hasStaticImportOfDynamicResource(node: TSESTree.ImportDeclaration | TSESTree.ImportExpression | TSESTree.ExportAllDeclaration | TSESTree.ExportNamedDeclaration, graph: ProjectGraph, sourceProjectName: string, targetProjectName: string, importExpr: string, filePath: string): boolean;
 export declare function getSourceFilePath(sourceFileName: string, projectPath: string): string;
 export declare function hasBannedImport(source: ProjectGraphProjectNode, target: ProjectGraphExternalNode, depConstraints: DepConstraint[], imp: string): DepConstraint | undefined;
 /**
@@ -80,7 +80,15 @@ export declare function groupImports(importsToRemap: {
 /**
  * Checks if source file belongs to a secondary entry point different than the import one
  */
-export declare function belongsToDifferentNgEntryPoint(importExpr: string, filePath: string, projectRoot: string): boolean;
+export declare function belongsToDifferentEntryPoint(importExpr: string, filePath: string, projectRoot: string): boolean;
+export declare function getSecondaryEntryPointPath(importExpr: string, filePath: string, projectRoot: string): string | undefined;
+export declare function parseExports(exports: string | null | Record<string, any>, projectRoot: string, entryPaths: Array<{
+    path: string;
+    file: string;
+}>, basePath?: string): Array<{
+    path: string;
+    file: string;
+}>;
 /**
  * Returns true if the given project contains MFE config with "exposes:" section
  */

package/src/utils/runtime-lint-utils.js

@@ -20,7 +20,9 @@ exports.isDirectDependency = isDirectDependency;
 exports.hasBuildExecutor = hasBuildExecutor;
 exports.isTerminalRun = isTerminalRun;
 exports.groupImports = groupImports;
-exports.belongsToDifferentNgEntryPoint = belongsToDifferentNgEntryPoint;
+exports.belongsToDifferentEntryPoint = belongsToDifferentEntryPoint;
+exports.getSecondaryEntryPointPath = getSecondaryEntryPointPath;
+exports.parseExports = parseExports;
 exports.appIsMFERemote = appIsMFERemote;
 exports.getParserServices = getParserServices;
 const tslib_1 = require("tslib");
@@ -135,14 +137,15 @@ function findConstraintsFor(depConstraints, sourceProject) {
         }
     });
 }
-function hasStaticImportOfDynamicResource(node, graph, sourceProjectName, targetProjectName) {
+function hasStaticImportOfDynamicResource(node, graph, sourceProjectName, targetProjectName, importExpr, filePath) {
     if (node.type !== utils_1.AST_NODE_TYPES.ImportDeclaration ||
         node.importKind === 'type') {
         return false;
     }
-    return onlyLoadChildren(graph, sourceProjectName, targetProjectName, []);
+    return (hasDynamicImport(graph, sourceProjectName, targetProjectName, []) &&
+        !getSecondaryEntryPointPath(importExpr, filePath, graph.nodes[targetProjectName].data.root));
 }
-function onlyLoadChildren(graph, sourceProjectName, targetProjectName, visited) {
+function hasDynamicImport(graph, sourceProjectName, targetProjectName, visited) {
     if (visited.indexOf(sourceProjectName) > -1) {
         return false;
     }
@@ -153,7 +156,7 @@ function onlyLoadChildren(graph, sourceProjectName, targetProjectName, visited)
         if (d.target === targetProjectName) {
             return true;
         }
-        return onlyLoadChildren(graph, d.target, targetProjectName, [
+        return hasDynamicImport(graph, d.target, targetProjectName, [
             ...visited,
             sourceProjectName,
         ]);
@@ -325,21 +328,34 @@ function groupImports(importsToRemap) {
 /**
  * Checks if source file belongs to a secondary entry point different than the import one
  */
-function belongsToDifferentNgEntryPoint(importExpr, filePath, projectRoot) {
+function belongsToDifferentEntryPoint(importExpr, filePath, projectRoot) {
+    const importEntryPoint = getSecondaryEntryPointPath(importExpr, filePath, projectRoot);
+    const srcEntryPoint = getEntryPoint(filePath, projectRoot);
+    // check if the entry point of import expression is different than the source file's entry point
+    return importEntryPoint !== srcEntryPoint;
+}
+function getSecondaryEntryPointPath(importExpr, filePath, projectRoot) {
     const resolvedImportFile = (0, internal_1.resolveModuleByImport)(importExpr, filePath, // not strictly necessary, but speeds up resolution
     path.join(devkit_1.workspaceRoot, (0, js_1.getRootTsConfigFileName)()));
     if (!resolvedImportFile) {
-        return false;
+        return undefined;
     }
-    const importEntryPoint = getAngularEntryPoint(resolvedImportFile, projectRoot);
-    const srcEntryPoint = getAngularEntryPoint(filePath, projectRoot);
-    // check if the entry point of import expression is different than the source file's entry point
-    return importEntryPoint !== srcEntryPoint;
+    const entryPoint = getEntryPoint(resolvedImportFile, projectRoot);
+    return entryPoint;
 }
-function getAngularEntryPoint(file, projectRoot) {
+function getEntryPoint(file, projectRoot) {
+    const packageEntryPoints = getPackageEntryPoints(projectRoot);
+    const fileEntryPoint = packageEntryPoints.find((entry) => entry.file === file);
+    if (fileEntryPoint) {
+        return fileEntryPoint.file;
+    }
     let parent = (0, devkit_1.joinPathFragments)(file, '../');
     while (parent !== `${projectRoot}/`) {
-        // we need to find closest existing ng-package.json
+        const entryPoint = packageEntryPoints.find((entry) => entry.path === parent);
+        if (entryPoint) {
+            return entryPoint.file;
+        }
+        // for Angular we need to find closest existing ng-package.json
         // in order to determine if the file matches the secondary entry point
         const ngPackageContent = (0, fileutils_1.readFileIfExisting)(path.join(devkit_1.workspaceRoot, parent, 'ng-package.json'));
         if (ngPackageContent) {
@@ -351,6 +367,45 @@ function getAngularEntryPoint(file, projectRoot) {
     }
     return undefined;
 }
+function getPackageEntryPoints(projectRoot) {
+    const packageContent = (0, fileutils_1.readFileIfExisting)(path.join(devkit_1.workspaceRoot, projectRoot, 'package.json'));
+    if (!packageContent) {
+        return [];
+    }
+    const exports = (0, devkit_1.parseJson)(packageContent).exports;
+    if (!exports) {
+        return [];
+    }
+    const entryPaths = [];
+    parseExports(exports, projectRoot, entryPaths);
+    return entryPaths;
+}
+function parseExports(exports, projectRoot, entryPaths, basePath = '.') {
+    if (exports === null) {
+        return;
+    }
+    if (typeof exports === 'string') {
+        if (basePath === '.') {
+            return;
+        }
+        else {
+            entryPaths.push({
+                path: (0, devkit_1.joinPathFragments)(projectRoot, basePath),
+                file: (0, devkit_1.joinPathFragments)(projectRoot, exports),
+            });
+            return;
+        }
+    }
+    // parse conditional exports
+    if (exports.import || exports.require || exports.default || exports.node) {
+        parseExports(exports.default || exports.import || exports.require || exports.node, projectRoot, entryPaths, basePath);
+        return;
+    }
+    // parse general nested exports
+    for (const [key, value] of Object.entries(exports)) {
+        parseExports(value, projectRoot, entryPaths, key);
+    }
+}
 /**
  * Returns true if the given project contains MFE config with "exposes:" section
  */