@nx/eslint-plugin 21.0.0-beta.1 → 21.0.0-beta.11

package/migrations.json

@@ -1,11 +1,5 @@
 {
   "generators": {
-    "update-17-2-6-rename-workspace-rules": {
-      "cli": "nx",
-      "version": "17.2.6-beta.1",
-      "description": "Rename workspace rules from @nx/workspace/name to @nx/workspace-name",
-      "implementation": "./src/migrations/update-17-2-6-rename-workspace-rules/rename-workspace-rules"
-    },
     "update-19-1-0-rename-no-extra-semi": {
       "cli": "nx",
       "version": "19.1.0-beta.6",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nx/eslint-plugin",
-  "version": "21.0.0-beta.1",
+  "version": "21.0.0-beta.11",
   "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": {
@@ -26,7 +26,7 @@
   "homepage": "https://nx.dev",
   "peerDependencies": {
     "@typescript-eslint/parser": "^6.13.2 || ^7.0.0 || ^8.0.0",
-    "eslint-config-prettier": "^9.0.0"
+    "eslint-config-prettier": "^10.0.0"
   },
   "peerDependenciesMeta": {
     "eslint-config-prettier": {
@@ -34,8 +34,8 @@
     }
   },
   "dependencies": {
-    "@nx/devkit": "21.0.0-beta.1",
-    "@nx/js": "21.0.0-beta.1",
+    "@nx/devkit": "21.0.0-beta.11",
+    "@nx/js": "21.0.0-beta.11",
     "@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/dependency-checks.d.ts

@@ -9,6 +9,7 @@ export type Options = [
         ignoredFiles?: string[];
         includeTransitiveDependencies?: boolean;
         useLocalPathsForWorkspaceDependencies?: boolean;
+        runtimeHelpers?: string[];
     }
 ];
 export type MessageIds = 'missingDependency' | 'obsoleteDependency' | 'versionMismatch' | 'missingDependencySection';

package/src/rules/dependency-checks.js

@@ -30,6 +30,7 @@ exports.default = utils_1.ESLintUtils.RuleCreator(() => `https://github.com/nrwl
                     checkVersionMismatches: { type: 'boolean' },
                     includeTransitiveDependencies: { type: 'boolean' },
                     useLocalPathsForWorkspaceDependencies: { type: 'boolean' },
+                    runtimeHelpers: { type: 'array', items: { type: 'string' } },
                 },
                 additionalProperties: false,
             },
@@ -51,9 +52,10 @@ exports.default = utils_1.ESLintUtils.RuleCreator(() => `https://github.com/nrwl
             ignoredFiles: [],
             includeTransitiveDependencies: false,
             useLocalPathsForWorkspaceDependencies: false,
+            runtimeHelpers: [],
         },
     ],
-    create(context, [{ buildTargets, ignoredDependencies, ignoredFiles, checkMissingDependencies, checkObsoleteDependencies, checkVersionMismatches, includeTransitiveDependencies, useLocalPathsForWorkspaceDependencies, },]) {
+    create(context, [{ buildTargets, ignoredDependencies, ignoredFiles, checkMissingDependencies, checkObsoleteDependencies, checkVersionMismatches, includeTransitiveDependencies, useLocalPathsForWorkspaceDependencies, runtimeHelpers, },]) {
         if (!(0, runtime_lint_utils_1.getParserServices)(context).isJSON) {
             return {};
         }
@@ -83,6 +85,7 @@ exports.default = utils_1.ESLintUtils.RuleCreator(() => `https://github.com/nrwl
             includeTransitiveDependencies,
             ignoredFiles,
             useLocalPathsForWorkspaceDependencies,
+            runtimeHelpers,
         });
         const expectedDependencyNames = Object.keys(npmDependencies);
         const packageJson = JSON.parse(context.sourceCode.getText());
@@ -129,7 +132,13 @@ exports.default = utils_1.ESLintUtils.RuleCreator(() => `https://github.com/nrwl
                 packageRange.startsWith('file:') ||
                 npmDependencies[packageName] === '*' ||
                 packageRange === '*' ||
-                packageRange === 'workspace:*' ||
+                packageRange.startsWith('workspace:') ||
+                /**
+                 * Catalogs can be named, or left unnamed
+                 * So just checking up until the : will catch both cases
+                 * e.g. catalog:some-catalog or catalog:
+                 */
+                packageRange.startsWith('catalog:') ||
                 (0, semver_1.satisfies)(npmDependencies[packageName], packageRange, {
                     includePrerelease: true,
                 })) {

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

@@ -10,6 +10,7 @@ const ast_utils_1 = require("../utils/ast-utils");
 const graph_utils_1 = require("../utils/graph-utils");
 const project_graph_utils_1 = require("../utils/project-graph-utils");
 const runtime_lint_utils_1 = require("../utils/runtime-lint-utils");
+const project_graph_1 = require("nx/src/config/project-graph");
 exports.RULE_NAME = 'enforce-module-boundaries';
 exports.default = utils_1.ESLintUtils.RuleCreator(() => `https://github.com/nrwl/nx/blob/${devkit_1.NX_VERSION}/docs/generated/packages/eslint-plugin/documents/enforce-module-boundaries.md`)({
     name: exports.RULE_NAME,
@@ -250,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',
@@ -328,6 +329,10 @@ exports.default = utils_1.ESLintUtils.RuleCreator(() => `https://github.com/nrwl
                 }
                 return;
             }
+            if (!(0, project_graph_1.isProjectGraphProjectNode)(targetProject)) {
+                return;
+            }
+            targetProject = targetProject;
             // check constraints between libs and apps
             // check for circular dependency
             const circularPath = (0, graph_utils_1.checkCircularPath)(projectGraph, sourceProject, targetProject);
@@ -386,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
  */

package/src/migrations/update-17-2-6-rename-workspace-rules/rename-workspace-rules.d.ts

@@ -1,2 +0,0 @@
-import { Tree } from '@nx/devkit';
-export default function renameWorkspaceRule(tree: Tree): Promise<void>;

package/src/migrations/update-17-2-6-rename-workspace-rules/rename-workspace-rules.js

@@ -1,29 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = renameWorkspaceRule;
-const devkit_1 = require("@nx/devkit");
-const binary_extensions_1 = require("@nx/devkit/src/utils/binary-extensions");
-const constants_1 = require("../../constants");
-async function renameWorkspaceRule(tree) {
-    if (!tree.exists(constants_1.WORKSPACE_RULES_PATH)) {
-        return;
-    }
-    let ruleNames = [];
-    try {
-        ruleNames = Object.keys(require(constants_1.WORKSPACE_PLUGIN_DIR).rules);
-    }
-    catch (e) {
-        return;
-    }
-    (0, devkit_1.visitNotIgnoredFiles)(tree, '.', (path) => {
-        if ((0, binary_extensions_1.isBinaryPath)(path)) {
-            return;
-        }
-        let contents = tree.read(path, 'utf-8');
-        ruleNames.forEach((ruleName) => {
-            contents = contents.replace(new RegExp(`@nx/workspace/${ruleName}`, 'g'), `@nx/workspace-${ruleName}`);
-        });
-        tree.write(path, contents);
-    });
-    await (0, devkit_1.formatFiles)(tree);
-}