@nx/eslint-plugin 23.0.0-beta.2 → 23.0.0-beta.21

package/{src → dist/src}/rules/nx-plugin-checks.js

@@ -5,6 +5,7 @@ exports.checkCollectionFileNode = checkCollectionFileNode;
 exports.checkCollectionNode = checkCollectionNode;
 exports.validateEntry = validateEntry;
 exports.validateImplementationNode = validateImplementationNode;
+exports.validatePromptNode = validatePromptNode;
 exports.validatePackageGroup = validatePackageGroup;
 exports.validateVersionJsonExpression = validateVersionJsonExpression;
 exports.checkIfIdentifierIsFunction = checkIfIdentifierIsFunction;
@@ -13,8 +14,8 @@ const utils_1 = require("@typescript-eslint/utils");
 const fs_1 = require("fs");
 const tsquery_1 = require("@phenomnomnominal/tsquery");
 const devkit_1 = require("@nx/devkit");
-const js_1 = require("@nx/js");
-const internal_1 = require("@nx/js/src/internal");
+const internal_1 = require("@nx/js/internal");
+const internal_2 = require("@nx/devkit/internal");
 const path = tslib_1.__importStar(require("path"));
 const semver_1 = require("semver");
 const project_graph_utils_1 = require("../utils/project-graph-utils");
@@ -79,6 +80,7 @@ exports.default = utils_1.ESLintUtils.RuleCreator(() => ``)({
             valueShouldBeObject: '{{ key }} should be an object',
             missingRequiredSchema: '{{ key }}: Missing required property - `schema`',
             missingImplementation: '{{ key }}: Missing required property - `implementation`',
+            invalidPromptPath: '{{ key }}: Prompt path should point to a valid file',
             missingVersion: '{{ key }}: Missing required property - `version`',
         },
     },
@@ -89,6 +91,10 @@ exports.default = utils_1.ESLintUtils.RuleCreator(() => ``)({
             return {};
         }
         const { projectGraph, projectRootMappings } = (0, project_graph_utils_1.readProjectGraph)(exports.RULE_NAME);
+        const projects = {};
+        for (const [projectName, node] of Object.entries(projectGraph.nodes)) {
+            projects[projectName] = node.data;
+        }
         const sourceFilePath = (0, runtime_lint_utils_1.getSourceFilePath)(context.filename ?? context.getFilename(), devkit_1.workspaceRoot);
         const sourceProject = (0, runtime_lint_utils_1.findProject)(projectGraph, projectRootMappings, sourceFilePath);
         // If source is not part of an nx workspace, return.
@@ -101,20 +107,16 @@ exports.default = utils_1.ESLintUtils.RuleCreator(() => ``)({
         if (![generatorsJson, executorsJson, migrationsJson, packageJson].includes(sourceFilePath)) {
             return {};
         }
-        if (!global.tsProjectRegistered) {
-            (0, internal_1.registerTsProject)((0, js_1.getRootTsConfigPath)());
-            global.tsProjectRegistered = true;
-        }
         return {
             ['JSONExpressionStatement > JSONObjectExpression'](node) {
                 if (sourceFilePath === generatorsJson) {
-                    checkCollectionFileNode(node, 'generator', context, options);
+                    checkCollectionFileNode(node, 'generator', context, projects);
                 }
                 else if (sourceFilePath === migrationsJson) {
-                    checkCollectionFileNode(node, 'migration', context, options);
+                    checkCollectionFileNode(node, 'migration', context, projects);
                 }
                 else if (sourceFilePath === executorsJson) {
-                    checkCollectionFileNode(node, 'executor', context, options);
+                    checkCollectionFileNode(node, 'executor', context, projects);
                 }
                 else if (sourceFilePath === packageJson) {
                     validatePackageGroup(node, context);
@@ -124,29 +126,7 @@ exports.default = utils_1.ESLintUtils.RuleCreator(() => ``)({
     },
 });
 function normalizeOptions(sourceProject, options) {
-    let rootDir;
-    let outDir;
     const base = { ...DEFAULT_OPTIONS, ...options };
-    let runtimeTsConfig;
-    if (sourceProject.data.targets?.build?.executor === '@nx/js:tsc') {
-        rootDir = sourceProject.data.targets.build.options.rootDir;
-        outDir = sourceProject.data.targets.build.options.outputPath;
-    }
-    if (!rootDir && !outDir) {
-        try {
-            runtimeTsConfig = require.resolve(path.join(devkit_1.workspaceRoot, sourceProject.data.root, base.tsConfig));
-            const tsConfig = (0, devkit_1.readJsonFile)(runtimeTsConfig);
-            rootDir ??= tsConfig.compilerOptions?.rootDir
-                ? path.join(sourceProject.data.root, tsConfig.compilerOptions.rootDir)
-                : undefined;
-            outDir ??= tsConfig.compilerOptions?.outDir
-                ? path.join(sourceProject.data.root, tsConfig.compilerOptions.outDir)
-                : undefined;
-        }
-        catch {
-            // nothing
-        }
-    }
     const pathPrefix = sourceProject.data.root !== '.' ? `${sourceProject.data.root}/` : '';
     return {
         ...base,
@@ -162,11 +142,9 @@ function normalizeOptions(sourceProject, options) {
         packageJson: base.packageJson
             ? `${pathPrefix}${base.packageJson}`
             : undefined,
-        rootDir,
-        outDir,
     };
 }
-function checkCollectionFileNode(baseNode, mode, context, options) {
+function checkCollectionFileNode(baseNode, mode, context, projects) {
     const schematicsRootNode = baseNode.properties.find((x) => x.key.type === 'JSONLiteral' && x.key.value === 'schematics');
     const generatorsRootNode = baseNode.properties.find((x) => x.key.type === 'JSONLiteral' && x.key.value === 'generators');
     const executorsRootNode = baseNode.properties.find((x) => x.key.type === 'JSONLiteral' && x.key.value === 'executors');
@@ -200,11 +178,11 @@ function checkCollectionFileNode(baseNode, mode, context, options) {
             });
         }
         else {
-            checkCollectionNode(collectionNode.value, mode, context, options);
+            checkCollectionNode(collectionNode.value, mode, context, projects);
         }
     }
 }
-function checkCollectionNode(baseNode, mode, context, options) {
+function checkCollectionNode(baseNode, mode, context, projects) {
     const entries = baseNode.properties;
     for (const entryNode of entries) {
         if (entryNode.value.type !== 'JSONObjectExpression') {
@@ -215,11 +193,11 @@ function checkCollectionNode(baseNode, mode, context, options) {
             });
         }
         else if (entryNode.key.type === 'JSONLiteral') {
-            validateEntry(entryNode.value, entryNode.key.value.toString(), mode, context, options);
+            validateEntry(entryNode.value, entryNode.key.value.toString(), mode, context, projects);
         }
     }
 }
-function validateEntry(baseNode, key, mode, context, options) {
+function validateEntry(baseNode, key, mode, context, projects) {
     const schemaNode = baseNode.properties.find((x) => x.key.type === 'JSONLiteral' && x.key.value === 'schema');
     if (mode !== 'migration' && !schemaNode) {
         context.report({
@@ -239,33 +217,26 @@ function validateEntry(baseNode, key, mode, context, options) {
             });
         }
         else {
-            let validJsonFound = false;
-            const schemaFilePath = path.join(path.dirname(context.filename ?? context.getFilename()), schemaNode.value.value);
             try {
-                (0, devkit_1.readJsonFile)(schemaFilePath);
-                validJsonFound = true;
+                (0, internal_2.resolveSchema)(schemaNode.value.value, path.dirname(context.filename ?? context.getFilename()), context.filename ?? context.getFilename(), projects);
             }
-            catch {
-                try {
-                    // Try to map back to source, which will be the case with TS solution setup.
-                    (0, devkit_1.readJsonFile)(schemaFilePath.replace(options.outDir, options.rootDir));
-                    validJsonFound = true;
+            catch (e) {
+                if (e instanceof internal_2.SchemaResolutionError) {
+                    context.report({
+                        messageId: 'invalidSchemaPath',
+                        node: schemaNode.value,
+                    });
                 }
-                catch {
-                    // nothing, will be reported below
+                else {
+                    throw e;
                 }
             }
-            if (!validJsonFound) {
-                context.report({
-                    messageId: 'invalidSchemaPath',
-                    node: schemaNode.value,
-                });
-            }
         }
     }
     const implementationNode = baseNode.properties.find((x) => x.key.type === 'JSONLiteral' &&
         (x.key.value === 'implementation' || x.key.value === 'factory'));
-    if (!implementationNode) {
+    const promptNode = baseNode.properties.find((x) => x.key.type === 'JSONLiteral' && x.key.value === 'prompt');
+    if (!implementationNode && !(mode === 'migration' && promptNode)) {
         context.report({
             messageId: 'missingImplementation',
             data: {
@@ -274,8 +245,11 @@ function validateEntry(baseNode, key, mode, context, options) {
             node: baseNode,
         });
     }
-    else {
-        validateImplementationNode(implementationNode, key, context, options);
+    else if (implementationNode) {
+        validateImplementationNode(implementationNode, key, context, projects);
+    }
+    if (mode === 'migration' && promptNode) {
+        validatePromptNode(promptNode, key, context);
     }
     if (mode === 'migration') {
         const versionNode = baseNode.properties.find((x) => x.key.type === 'JSONLiteral' && x.key.value === 'version');
@@ -312,7 +286,7 @@ function validateEntry(baseNode, key, mode, context, options) {
         }
     }
 }
-function validateImplementationNode(implementationNode, key, context, options) {
+function validateImplementationNode(implementationNode, key, context, projects) {
     if (implementationNode.value.type !== 'JSONLiteral' ||
         typeof implementationNode.value.value !== 'string') {
         context.report({
@@ -326,28 +300,24 @@ function validateImplementationNode(implementationNode, key, context, options) {
     else {
         const [implementationPath, identifier] = implementationNode.value.value.split('#');
         let resolvedPath;
-        const modulePath = path.join(path.dirname(context.filename ?? context.getFilename()), implementationPath);
         try {
-            resolvedPath = require.resolve(modulePath);
+            resolvedPath = (0, internal_2.resolveImplementation)(implementationPath, path.dirname(context.filename ?? context.getFilename()), context.filename ?? context.getFilename(), projects);
         }
-        catch {
-            try {
-                resolvedPath = require.resolve(modulePath.replace(options.outDir, options.rootDir));
+        catch (e) {
+            if (e instanceof internal_2.ImplementationResolutionError) {
+                context.report({
+                    messageId: 'invalidImplementationPath',
+                    data: {
+                        key,
+                    },
+                    node: implementationNode.value,
+                });
             }
-            catch {
-                // nothing, will be reported below
+            else {
+                throw e;
             }
         }
-        if (!resolvedPath) {
-            context.report({
-                messageId: 'invalidImplementationPath',
-                data: {
-                    key,
-                },
-                node: implementationNode.value,
-            });
-        }
-        if (identifier) {
+        if (resolvedPath && identifier) {
             try {
                 if (!checkIfIdentifierIsFunction(resolvedPath, identifier)) {
                     context.report({
@@ -373,6 +343,36 @@ function validateImplementationNode(implementationNode, key, context, options) {
         }
     }
 }
+function validatePromptNode(promptNode, key, context) {
+    if (promptNode.value.type !== 'JSONLiteral' ||
+        typeof promptNode.value.value !== 'string') {
+        context.report({
+            messageId: 'invalidPromptPath',
+            data: {
+                key,
+            },
+            node: promptNode.value,
+        });
+        return;
+    }
+    try {
+        (0, internal_2.resolvePrompt)(promptNode.value.value, path.dirname(context.filename ?? context.getFilename()));
+    }
+    catch (e) {
+        if (e instanceof internal_2.PromptResolutionError) {
+            context.report({
+                messageId: 'invalidPromptPath',
+                data: {
+                    key,
+                },
+                node: promptNode.value,
+            });
+        }
+        else {
+            throw e;
+        }
+    }
+}
 function validatePackageGroup(baseNode, context) {
     const migrationsNode = baseNode.properties.find((x) => x.key.type === 'JSONLiteral' &&
         x.value.type === 'JSONObjectExpression' &&
@@ -452,6 +452,8 @@ function checkIfIdentifierIsFunction(filePath, identifier) {
         // ignore
     }
     // Fallback to require()
-    const m = require(filePath);
+    const m = /\.[cm]?ts$/.test(filePath)
+        ? (0, internal_1.loadTsFile)(filePath)
+        : (0, internal_1.requireWithTsconfigFallback)(filePath);
     return identifier in m && typeof m[identifier] === 'function';
 }

package/{src → dist/src}/utils/ast-utils.d.ts

@@ -10,4 +10,3 @@ export declare function getBarrelEntryPointProjectNode(projectNode: ProjectGraph
     importScope: string;
 }[] | null;
 export declare function getRelativeImportPath(exportedMember: any, filePath: any): any;
-//# sourceMappingURL=ast-utils.d.ts.map

package/{src → dist/src}/utils/ast-utils.js

@@ -5,7 +5,7 @@ exports.getBarrelEntryPointProjectNode = getBarrelEntryPointProjectNode;
 exports.getRelativeImportPath = getRelativeImportPath;
 const devkit_1 = require("@nx/devkit");
 const js_1 = require("@nx/js");
-const ts_solution_setup_1 = require("@nx/js/src/utils/typescript/ts-solution-setup");
+const internal_1 = require("@nx/js/internal");
 const type_utils_1 = require("@typescript-eslint/type-utils");
 const fs_1 = require("fs");
 const path_1 = require("path");
@@ -61,7 +61,7 @@ function getBarrelEntryPointProjectNode(projectNode) {
             const sourceFolderPaths = tsConfigBase.compilerOptions.paths[entry];
             return sourceFolderPaths.some((sourceFolderPath) => {
                 const normalizedPath = sourceFolderPath.replace(/^\.\//, '');
-                const sourceRoot = (0, ts_solution_setup_1.getProjectSourceRoot)(projectNode.data);
+                const sourceRoot = (0, internal_1.getProjectSourceRoot)(projectNode.data);
                 return (normalizedPath === sourceRoot ||
                     normalizedPath.indexOf(`${sourceRoot}/`) === 0);
             });
@@ -91,6 +91,9 @@ function getRelativeImportPath(exportedMember, filePath) {
         if (ext) {
             filePath += ext;
         }
+        else {
+            return;
+        }
     }
     else if (status.isDirectory()) {
         const file = (0, fs_1.readdirSync)(filePath).find((file) => /^index\.[jt]sx?$/.exec(file));

package/{src → dist/src}/utils/config-utils.d.ts

@@ -4,4 +4,3 @@
  * @returns
  */
 export declare function packageExists(name: string): boolean;
-//# sourceMappingURL=config-utils.d.ts.map

package/{src → dist/src}/utils/graph-utils.d.ts

@@ -6,4 +6,3 @@ export declare function circularPathHasPair(circularPath: ProjectGraphProjectNod
 export declare function findFilesInCircularPath(projectFileMap: ProjectFileMap, circularPath: ProjectGraphProjectNode[]): Array<string[]>;
 export declare function findFilesWithDynamicImports(projectFileMap: ProjectFileMap, sourceProjectName: string, targetProjectName: string): FileData[];
 export declare function expandIgnoredCircularDependencies(ignoredCircularDependencies: Array<[string, string]>, projectGraph: ProjectGraph): Map<string, Set<string>>;
-//# sourceMappingURL=graph-utils.d.ts.map

package/{src → dist/src}/utils/package-json-utils.d.ts

@@ -2,4 +2,3 @@ import type { PackageJson } from 'nx/src/utils/package-json';
 export declare function getAllDependencies(packageJson: PackageJson): Record<string, string>;
 export declare function getProductionDependencies(packageJson: PackageJson): Record<string, string>;
 export declare function getPackageJson(path: string): PackageJson;
-//# sourceMappingURL=package-json-utils.d.ts.map

package/{src → dist/src}/utils/project-graph-utils.d.ts

@@ -1,6 +1,6 @@
 import { ProjectFileMap, ProjectGraph } from '@nx/devkit';
 import { ProjectRootMappings } from 'nx/src/project-graph/utils/find-project-for-path';
-import { TargetProjectLocator } from '@nx/js/src/internal';
+import { TargetProjectLocator } from '@nx/js/internal';
 export declare function ensureGlobalProjectGraph(ruleName: string): void;
 export declare function readProjectGraph(ruleName: string): {
     projectGraph: ProjectGraph;
@@ -8,4 +8,3 @@ export declare function readProjectGraph(ruleName: string): {
     projectRootMappings: ProjectRootMappings;
     targetProjectLocator: TargetProjectLocator;
 };
-//# sourceMappingURL=project-graph-utils.d.ts.map

package/{src → dist/src}/utils/project-graph-utils.js

@@ -7,7 +7,7 @@ const runtime_lint_utils_1 = require("./runtime-lint-utils");
 const chalk = require("chalk");
 const find_project_for_path_1 = require("nx/src/project-graph/utils/find-project-for-path");
 const configuration_1 = require("nx/src/config/configuration");
-const internal_1 = require("@nx/js/src/internal");
+const internal_1 = require("@nx/js/internal");
 const nx_deps_cache_1 = require("nx/src/project-graph/nx-deps-cache");
 function ensureGlobalProjectGraph(ruleName) {
     /**

package/{src → dist/src}/utils/runtime-lint-utils.d.ts

@@ -1,5 +1,5 @@
 import { ProjectGraph, ProjectGraphDependency, ProjectGraphExternalNode, ProjectGraphProjectNode } from '@nx/devkit';
-import { TargetProjectLocator } from '@nx/js/src/internal';
+import { TargetProjectLocator } from '@nx/js/internal';
 import { TSESLint, TSESTree } from '@typescript-eslint/utils';
 import { ProjectRootMappings } from 'nx/src/project-graph/utils/find-project-for-path';
 export type Deps = {
@@ -99,4 +99,3 @@ export declare function appIsMFERemote(project: ProjectGraphProjectNode): boolea
  */
 export declare function getParserServices(context: Readonly<TSESLint.RuleContext<any, any>>): any;
 export {};
-//# sourceMappingURL=runtime-lint-utils.d.ts.map

package/{src → dist/src}/utils/runtime-lint-utils.js

@@ -28,7 +28,6 @@ exports.getParserServices = getParserServices;
 const tslib_1 = require("tslib");
 const devkit_1 = require("@nx/devkit");
 const js_1 = require("@nx/js");
-const internal_1 = require("@nx/js/src/internal");
 const utils_1 = require("@typescript-eslint/utils");
 const path = tslib_1.__importStar(require("node:path"));
 const find_project_for_path_1 = require("nx/src/project-graph/utils/find-project-for-path");
@@ -335,7 +334,7 @@ function belongsToDifferentEntryPoint(importExpr, filePath, projectRoot) {
     return importEntryPoint !== srcEntryPoint;
 }
 function getSecondaryEntryPointPath(importExpr, filePath, projectRoot) {
-    const resolvedImportFile = (0, internal_1.resolveModuleByImport)(importExpr, filePath, // not strictly necessary, but speeds up resolution
+    const resolvedImportFile = (0, js_1.resolveModuleByImport)(importExpr, filePath, // not strictly necessary, but speeds up resolution
     path.join(devkit_1.workspaceRoot, (0, js_1.getRootTsConfigFileName)()));
     if (!resolvedImportFile) {
         return undefined;

package/{typescript.d.ts → dist/typescript.d.ts}

@@ -4,4 +4,3 @@ declare const plugin: {
     rules: {};
 };
 export default plugin;
-//# sourceMappingURL=typescript.d.ts.map

package/package.json

@@ -1,7 +1,14 @@
 {
   "name": "@nx/eslint-plugin",
-  "version": "23.0.0-beta.2",
+  "version": "23.0.0-beta.21",
   "private": false,
+  "type": "commonjs",
+  "files": [
+    "dist",
+    "!dist/tsconfig.tsbuildinfo",
+    "!dist/spec",
+    "migrations.json"
+  ],
   "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": {
     "type": "git",
@@ -16,44 +23,91 @@
     "CLI",
     "Testing"
   ],
-  "main": "./src/index.js",
-  "type": "commonjs",
-  "types": "./src/index.d.ts",
+  "main": "./dist/src/index.js",
+  "types": "./dist/src/index.d.ts",
+  "typesVersions": {
+    "*": {
+      "angular": [
+        "dist/angular.d.ts"
+      ],
+      "nx": [
+        "dist/nx.d.ts"
+      ],
+      "react": [
+        "dist/react.d.ts"
+      ],
+      "typescript": [
+        "dist/typescript.d.ts"
+      ]
+    }
+  },
   "author": "Victor Savkin",
   "license": "MIT",
   "bugs": {
     "url": "https://github.com/nrwl/nx/issues"
   },
   "homepage": "https://nx.dev",
+  "nx-migrations": {
+    "migrations": "./migrations.json"
+  },
+  "exports": {
+    ".": {
+      "@nx/nx-source": "./src/index.ts",
+      "types": "./dist/src/index.d.ts",
+      "default": "./dist/src/index.js"
+    },
+    "./package.json": "./package.json",
+    "./migrations.json": "./migrations.json",
+    "./angular": {
+      "@nx/nx-source": "./angular.ts",
+      "types": "./dist/angular.d.ts",
+      "default": "./dist/angular.js"
+    },
+    "./nx": {
+      "@nx/nx-source": "./nx.ts",
+      "types": "./dist/nx.d.ts",
+      "default": "./dist/nx.js"
+    },
+    "./react": {
+      "@nx/nx-source": "./react.ts",
+      "types": "./dist/react.d.ts",
+      "default": "./dist/react.js"
+    },
+    "./typescript": {
+      "@nx/nx-source": "./typescript.ts",
+      "types": "./dist/typescript.d.ts",
+      "default": "./dist/typescript.js"
+    }
+  },
   "peerDependencies": {
-    "@typescript-eslint/parser": "^6.13.2 || ^7.0.0 || ^8.0.0",
+    "@typescript-eslint/parser": "^8.0.0",
     "eslint-config-prettier": "^10.0.0"
   },
   "peerDependenciesMeta": {
+    "@typescript-eslint/parser": {
+      "optional": true
+    },
     "eslint-config-prettier": {
       "optional": true
     }
   },
   "dependencies": {
-    "@nx/devkit": "23.0.0-beta.2",
-    "@nx/js": "23.0.0-beta.2",
-    "@phenomnomnominal/tsquery": "~6.1.4",
+    "@phenomnomnominal/tsquery": "~6.2.0",
     "@typescript-eslint/type-utils": "^8.0.0",
     "@typescript-eslint/utils": "^8.0.0",
     "chalk": "^4.1.0",
     "confusing-browser-globals": "^1.0.9",
-    "globals": "^15.9.0",
+    "globals": "^17.0.0",
     "jsonc-eslint-parser": "^2.1.0",
     "semver": "^7.6.3",
-    "tslib": "^2.3.0"
+    "tslib": "^2.3.0",
+    "@nx/js": "23.0.0-beta.21",
+    "@nx/devkit": "23.0.0-beta.21"
   },
   "devDependencies": {
-    "nx": "23.0.0-beta.2"
+    "nx": "23.0.0-beta.21"
   },
   "publishConfig": {
     "access": "public"
-  },
-  "nx-migrations": {
-    "migrations": "./migrations.json"
   }
 }

package/angular.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"angular.d.ts","sourceRoot":"","sources":["../../../packages/eslint-plugin/angular.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAIrD,QAAA,MAAM,MAAM;aAIL,MAAM,CAAC,MAAM,EAAE,WAAW,CAAC;;CAEjC,CAAC;AAGF,eAAe,MAAM,CAAC"}

package/nx.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"nx.d.ts","sourceRoot":"","sources":["../../../packages/eslint-plugin/nx.ts"],"names":[],"mappings":"AAWA,QAAA,MAAM,MAAM;;;;;;;CASX,CAAC;AAGF,eAAe,MAAM,CAAC"}

package/react.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"react.d.ts","sourceRoot":"","sources":["../../../packages/eslint-plugin/react.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAMrD,QAAA,MAAM,MAAM;aAML,MAAM,CAAC,MAAM,EAAE,WAAW,CAAC;;CAEjC,CAAC;AAGF,eAAe,MAAM,CAAC"}

package/src/configs/angular-template.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"angular-template.d.ts","sourceRoot":"","sources":["../../../../../packages/eslint-plugin/src/configs/angular-template.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;;;;;;AACH,wBAIE"}

package/src/configs/angular.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"angular.d.ts","sourceRoot":"","sources":["../../../../../packages/eslint-plugin/src/configs/angular.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;;;;;;;;;;;;;;AACH,wBAaE"}

package/src/configs/javascript.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"javascript.d.ts","sourceRoot":"","sources":["../../../../../packages/eslint-plugin/src/configs/javascript.ts"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;;;GAeG;;;;;;;;;;;;;;;;;;QAuBC;;;;WAIG;;QAGH;;;;;;;;WAQG;;;;;;;;;;QAUH;;;;;WAKG;;;;AApDP,wBAuDE"}

package/src/configs/react-base.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"react-base.d.ts","sourceRoot":"","sources":["../../../../../packages/eslint-plugin/src/configs/react-base.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH;;;GAGG;;;;;;;;;;;QAWC;;;WAGG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QA0GH;;;WAGG;;;;;;AA1HP,wBA+HE"}

package/src/configs/react-jsx.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"react-jsx.d.ts","sourceRoot":"","sources":["../../../../../packages/eslint-plugin/src/configs/react-jsx.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;;;;;;;;;;QAMC;;;WAGG;;;;;;;;;;;;;;;;;;;;;;QAkBH;;;WAGG;;;;;;;;;;;;;;;;;;;;;;;AA7BP,wBAoDE"}

package/src/configs/react-tmp.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"react-tmp.d.ts","sourceRoot":"","sources":["../../../../../packages/eslint-plugin/src/configs/react-tmp.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;;;;AACH,wBAME"}

package/src/configs/react-typescript.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"react-typescript.d.ts","sourceRoot":"","sources":["../../../../../packages/eslint-plugin/src/configs/react-typescript.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AACH,wBA0CE"}

package/src/configs/typescript.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"typescript.d.ts","sourceRoot":"","sources":["../../../../../packages/eslint-plugin/src/configs/typescript.ts"],"names":[],"mappings":"AAMA;;;;;;GAMG;;;;;;;;;;;;;;;QAqBC;;;;;;;;WAQG;;;;;;;;;;QAUH;;;;;WAKG;;;;AA3CP,wBA8CE"}

package/src/constants.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../../../packages/eslint-plugin/src/constants.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,oBAAoB,uBAAuB,CAAC;AAEzD,eAAO,MAAM,oBAAoB,QAA4C,CAAC;AAE9E;;;;;;;;;GASG;AACH,eAAO,MAAM,qBAAqB,cAAc,CAAC"}

package/src/flat-configs/angular-template.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"angular-template.d.ts","sourceRoot":"","sources":["../../../../../packages/eslint-plugin/src/flat-configs/angular-template.ts"],"names":[],"mappings":"AACA,OAAiB,EAAE,KAAK,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAE/D;;;;;;;;;;;;;GAaG;AACH,QAAA,MAAM,MAAM,EAAE,WAOL,CAAC;AAEV,eAAe,MAAM,CAAC"}

package/src/flat-configs/angular.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"angular.d.ts","sourceRoot":"","sources":["../../../../../packages/eslint-plugin/src/flat-configs/angular.ts"],"names":[],"mappings":"AAEA,OAAiB,EAAE,KAAK,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAE/D;;;;;;;;;;GAUG;AACH,QAAA,MAAM,MAAM,EAAE,WAqBb,CAAC;AAEF,eAAe,MAAM,CAAC"}

package/src/flat-configs/base.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"base.d.ts","sourceRoot":"","sources":["../../../../../packages/eslint-plugin/src/flat-configs/base.ts"],"names":[],"mappings":";;;;;;AAAA,wBASE"}

package/src/flat-configs/javascript.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"javascript.d.ts","sourceRoot":"","sources":["../../../../../packages/eslint-plugin/src/flat-configs/javascript.ts"],"names":[],"mappings":"AAEA,OAAiB,EAAE,KAAK,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAM/D;;;;;;;;;;;;;;;GAeG;AACH,QAAA,MAAM,MAAM,EAAE,WA+Db,CAAC;AAEF,eAAe,MAAM,CAAC"}

package/src/flat-configs/react-base.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"react-base.d.ts","sourceRoot":"","sources":["../../../../../packages/eslint-plugin/src/flat-configs/react-base.ts"],"names":[],"mappings":"AAEA,OAAiB,EAAE,KAAK,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAE/D;;;;;;;;;GASG;AAEH;;;GAGG;AACH,QAAA,MAAM,MAAM,EAAE,WAyIZ,CAAC;AAEH,eAAe,MAAM,CAAC"}

package/src/flat-configs/react-jsx.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"react-jsx.d.ts","sourceRoot":"","sources":["../../../../../packages/eslint-plugin/src/flat-configs/react-jsx.ts"],"names":[],"mappings":"AAGA,OAAiB,EAAE,KAAK,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAE/D;;;;;;;;;GASG;AACH,QAAA,MAAM,MAAM,EAAE,WAkFb,CAAC;AAEF,eAAe,MAAM,CAAC"}

package/src/flat-configs/react-tmp.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"react-tmp.d.ts","sourceRoot":"","sources":["../../../../../packages/eslint-plugin/src/flat-configs/react-tmp.ts"],"names":[],"mappings":"AAAA,OAAiB,EAAE,KAAK,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAK/D;;;;;;;GAOG;AACH,QAAA,MAAM,MAAM,EAAE,WAIb,CAAC;AAEF,eAAe,MAAM,CAAC"}

package/src/flat-configs/react-typescript.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"react-typescript.d.ts","sourceRoot":"","sources":["../../../../../packages/eslint-plugin/src/flat-configs/react-typescript.ts"],"names":[],"mappings":"AAAA,OAAiB,EAAE,KAAK,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAE/D;;;;;;;;;GASG;AACH,QAAA,MAAM,MAAM,EAAE,WAoDZ,CAAC;AAEH,eAAe,MAAM,CAAC"}

package/src/flat-configs/typescript.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"typescript.d.ts","sourceRoot":"","sources":["../../../../../packages/eslint-plugin/src/flat-configs/typescript.ts"],"names":[],"mappings":"AAEA,OAAiB,EAAE,KAAK,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAM/D;;;;;;GAMG;AACH,QAAA,MAAM,MAAM,EAAE,WAwDb,CAAC;AAEF,eAAe,MAAM,CAAC"}

package/src/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../packages/eslint-plugin/src/index.ts"],"names":[],"mappings":"AAwBA,OAAO,EAAkB,kBAAkB,EAAE,MAAM,2BAA2B,CAAC;AAE/E,QAAA,MAAM,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gCAcgB,cAAc,2BAA2B,EAAE,OAAO;gCAGlD,cAAc,2BAA2B,EAAE,OAAO;2BAGvD,cAAc,0BAA0B,EAAE,OAAO;gCAG5C,cAAc,2BAA2B,EAAE,OAAO;sCAG5C,cAAc,iCAAiC,EAAE,OAAO;+BAG/D,cAAc,0BAA0B,EAAE,OAAO;6BAGnD,cAAc,wBAAwB,EAAE,OAAO;sCAGtC,cAAc,iCAAiC,EAAE,OAAO;CAG1F,CAAC;AAEF,QAAA,MAAM,KAAK;;;;CAKV,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oCA/B2B,cAAc,2BAA2B,EAAE,OAAO;oCAGlD,cAAc,2BAA2B,EAAE,OAAO;+BAGvD,cAAc,0BAA0B,EAAE,OAAO;oCAG5C,cAAc,2BAA2B,EAAE,OAAO;0CAG5C,cAAc,iCAAiC,EAAE,OAAO;mCAG/D,cAAc,0BAA0B,EAAE,OAAO;iCAGnD,cAAc,wBAAwB,EAAE,OAAO;0CAGtC,cAAc,iCAAiC,EAAE,OAAO;;;;;;;;AAY3F,wBAAkC;AAClC,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,kBAAkB,EAAE,CAAC"}

package/src/resolve-workspace-rules.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"resolve-workspace-rules.d.ts","sourceRoot":"","sources":["../../../../packages/eslint-plugin/src/resolve-workspace-rules.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AAKzD,KAAK,WAAW,GAAG,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,UAAU,CAAC,MAAM,EAAE,OAAO,EAAE,CAAC,CAAC,CAAC;AAiF1E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,wBAAsB,kBAAkB,CACtC,SAAS,EAAE,MAAM,EACjB,YAAY,CAAC,EAAE,MAAM,GACpB,OAAO,CAAC,WAAW,CAAC,CA2CtB;AAED,eAAO,MAAM,cAAc,aAgCvB,CAAC"}

package/src/rules/dependency-checks.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"dependency-checks.d.ts","sourceRoot":"","sources":["../../../../../packages/eslint-plugin/src/rules/dependency-checks.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAC;AAmBvD,MAAM,MAAM,OAAO,GAAG;IACpB;QACE,YAAY,CAAC,EAAE,MAAM,EAAE,CAAC;QACxB,wBAAwB,CAAC,EAAE,OAAO,CAAC;QACnC,yBAAyB,CAAC,EAAE,OAAO,CAAC;QACpC,sBAAsB,CAAC,EAAE,OAAO,CAAC;QACjC,mBAAmB,CAAC,EAAE,MAAM,EAAE,CAAC;QAC/B,YAAY,CAAC,EAAE,MAAM,EAAE,CAAC;QACxB,6BAA6B,CAAC,EAAE,OAAO,CAAC;QACxC,qCAAqC,CAAC,EAAE,OAAO,CAAC;QAChD,cAAc,CAAC,EAAE,MAAM,EAAE,CAAC;QAC1B,uBAAuB,CAAC,EAAE,WAAW,GAAG,WAAW,CAAC;KACrD;CACF,CAAC;AAEF,MAAM,MAAM,UAAU,GAClB,mBAAmB,GACnB,oBAAoB,GACpB,iBAAiB,GACjB,0BAA0B,GAC1B,yBAAyB,CAAC;AAE9B,eAAO,MAAM,SAAS,sBAAsB,CAAC;;AAE7C,wBAkgBG"}

package/src/rules/enforce-module-boundaries.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"enforce-module-boundaries.d.ts","sourceRoot":"","sources":["../../../../../packages/eslint-plugin/src/rules/enforce-module-boundaries.ts"],"names":[],"mappings":"AAQA,OAAO,EAEL,WAAW,EAEZ,MAAM,0BAA0B,CAAC;AAiBlC,OAAO,EAGL,aAAa,EAmBd,MAAM,6BAA6B,CAAC;AAGrC,MAAM,MAAM,OAAO,GAAG;IACpB;QACE,KAAK,EAAE,MAAM,EAAE,CAAC;QAChB,YAAY,EAAE,MAAM,EAAE,CAAC;QACvB,cAAc,EAAE,aAAa,EAAE,CAAC;QAChC,6BAA6B,EAAE,OAAO,CAAC;QACvC,2BAA2B,EAAE,OAAO,CAAC;QACrC,2BAA2B,EAAE,KAAK,CAAC,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;QACrD,kCAAkC,EAAE,MAAM,EAAE,CAAC;QAC7C,yBAAyB,EAAE,OAAO,CAAC;QACnC,0BAA0B,EAAE,OAAO,CAAC;KACrC;CACF,CAAC;AACF,MAAM,MAAM,UAAU,GAClB,4CAA4C,GAC5C,+BAA+B,GAC/B,4BAA4B,GAC5B,wBAAwB,GACxB,iBAAiB,GACjB,gBAAgB,GAChB,iCAAiC,GACjC,gCAAgC,GAChC,0CAA0C,GAC1C,gCAAgC,GAChC,sCAAsC,GACtC,0BAA0B,GAC1B,6BAA6B,GAC7B,kCAAkC,GAClC,4BAA4B,CAAC;AACjC,eAAO,MAAM,SAAS,8BAA8B,CAAC;;AAErD,wBA0wBG"}

package/src/rules/nx-plugin-checks.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"nx-plugin-checks.d.ts","sourceRoot":"","sources":["../../../../../packages/eslint-plugin/src/rules/nx-plugin-checks.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AAEzD,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,qBAAqB,CAAC;AAoB/C,MAAM,MAAM,OAAO,GAAG;IACpB;QACE,cAAc,CAAC,EAAE,MAAM,CAAC;QACxB,aAAa,CAAC,EAAE,MAAM,CAAC;QACvB,cAAc,CAAC,EAAE,MAAM,CAAC;QACxB,WAAW,CAAC,EAAE,MAAM,CAAC;QACrB,qBAAqB,EAAE,MAAM,EAAE,CAAC;QAChC,QAAQ,CAAC,EAAE,MAAM,CAAC;KACnB;CACF,CAAC;AAEF,KAAK,iBAAiB,GAAG,OAAO,CAAC,CAAC,CAAC,GAAG;IACpC,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB,CAAC;AAWF,MAAM,MAAM,UAAU,GAClB,uBAAuB,GACvB,mBAAmB,GACnB,uBAAuB,GACvB,2BAA2B,GAC3B,6BAA6B,GAC7B,mCAAmC,GACnC,gBAAgB,GAChB,gBAAgB,GAChB,+BAA+B,GAC/B,4BAA4B,GAC5B,qBAAqB,CAAC;AAE1B,eAAO,MAAM,SAAS,qBAAqB,CAAC;;AAE5C,wBA2HG;AAqDH,wBAAgB,uBAAuB,CACrC,QAAQ,EAAE,GAAG,CAAC,oBAAoB,EAClC,IAAI,EAAE,WAAW,GAAG,WAAW,GAAG,UAAU,EAC5C,OAAO,EAAE,QAAQ,CAAC,WAAW,CAAC,UAAU,EAAE,OAAO,CAAC,EAClD,OAAO,EAAE,iBAAiB,QAkD3B;AAED,wBAAgB,mBAAmB,CACjC,QAAQ,EAAE,GAAG,CAAC,oBAAoB,EAClC,IAAI,EAAE,WAAW,GAAG,WAAW,GAAG,UAAU,EAC5C,OAAO,EAAE,QAAQ,CAAC,WAAW,CAAC,UAAU,EAAE,OAAO,CAAC,EAClD,OAAO,EAAE,iBAAiB,QAqB3B;AAED,wBAAgB,aAAa,CAC3B,QAAQ,EAAE,GAAG,CAAC,oBAAoB,EAClC,GAAG,EAAE,MAAM,EACX,IAAI,EAAE,WAAW,GAAG,WAAW,GAAG,UAAU,EAC5C,OAAO,EAAE,QAAQ,CAAC,WAAW,CAAC,UAAU,EAAE,OAAO,CAAC,EAClD,OAAO,EAAE,iBAAiB,GACzB,IAAI,CAsGN;AAED,wBAAgB,0BAA0B,CACxC,kBAAkB,EAAE,GAAG,CAAC,YAAY,EACpC,GAAG,EAAE,MAAM,EACX,OAAO,EAAE,QAAQ,CAAC,WAAW,CAAC,UAAU,EAAE,OAAO,CAAC,EAClD,OAAO,EAAE,iBAAiB,QAqE3B;AAED,wBAAgB,oBAAoB,CAClC,QAAQ,EAAE,GAAG,CAAC,oBAAoB,EAClC,OAAO,EAAE,QAAQ,CAAC,WAAW,CAAC,UAAU,EAAE,OAAO,CAAC,QAsEnD;AAED,wBAAgB,6BAA6B,CAC3C,IAAI,EAAE,GAAG,CAAC,cAAc,EACxB,OAAO,EAAE,QAAQ,CAAC,WAAW,CAAC,UAAU,EAAE,OAAO,CAAC,oBASnD;AAED,wBAAgB,2BAA2B,CACzC,QAAQ,EAAE,MAAM,EAChB,UAAU,EAAE,MAAM,GACjB,OAAO,CAgCT"}

package/src/utils/ast-utils.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ast-utils.d.ts","sourceRoot":"","sources":["../../../../../packages/eslint-plugin/src/utils/ast-utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,uBAAuB,EAGxB,MAAM,YAAY,CAAC;AAiBpB;;;;GAIG;AACH,wBAAgB,gCAAgC,CAC9C,WAAW,EAAE,MAAM,GAClB,MAAM,EAAE,CAgCV;AAED,wBAAgB,8BAA8B,CAC5C,WAAW,EAAE,uBAAuB,GACnC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,WAAW,EAAE,MAAM,CAAA;CAAE,EAAE,GAAG,IAAI,CA2BhD;AAqBD,wBAAgB,qBAAqB,CAAC,cAAc,KAAA,EAAE,QAAQ,KAAA,OA+K7D"}