@taiga-ui/eslint-plugin-experience-next 0.383.0 → 0.384.0

package/index.esm.js

@@ -1749,54 +1749,154 @@ var noDeepImportsToIndexedPackages = createRule$5({
         const parserServices = ESLintUtils.getParserServices(context);
         const program = parserServices.program;
         const compilerHost = ts.createCompilerHost(program.getCompilerOptions(), true);
+        function resolveTypescriptModule(moduleSpecifier) {
+            const resolved = ts.resolveModuleName(moduleSpecifier, context.filename, program.getCompilerOptions(), compilerHost);
+            return resolved.resolvedModule?.resolvedFileName ?? null;
+        }
         return {
             ImportDeclaration(node) {
-                const importPath = node.source.value;
-                if (typeof importPath !== 'string' || importPath.startsWith('.')) {
+                const importSpecifier = node.source.value;
+                if (typeof importSpecifier !== 'string') {
                     return;
                 }
-                const containingFile = context.filename;
-                const { resolvedModule } = ts.resolveModuleName(importPath, containingFile, program.getCompilerOptions(), compilerHost);
-                const resolvedPath = resolvedModule?.resolvedFileName;
-                if (!resolvedPath || resolvedPath.endsWith('index.ts')) {
+                if (!isExternalModuleSpecifier(importSpecifier)) {
                     return;
                 }
-                const dir = path.dirname(resolvedPath);
-                const baseDir = path.resolve(dir, '..');
-                const indexPath = path.join(baseDir, 'index.ts');
-                const ngPackagePath = path.join(baseDir, 'ng-package.json');
-                const packageJsonPath = path.join(baseDir, 'package.json');
-                const hasIndex = fs.existsSync(indexPath);
-                const hasPackage = fs.existsSync(ngPackagePath) || fs.existsSync(packageJsonPath);
-                if (hasIndex && hasPackage) {
-                    const relative = path.relative(baseDir, resolvedPath);
-                    const shouldFix = !!(relative && !relative.startsWith('..'));
-                    if (shouldFix) {
-                        const parts = importPath.split('/');
-                        const suggestedImport = parts.slice(0, -1).join('/');
-                        context.report({
-                            data: { importPath, suggestedImport },
-                            messageId: 'deepImport',
-                            node: node.source,
-                        });
-                    }
+                const packageRootSpecifier = getPackageRootSpecifier(importSpecifier);
+                const importSubpath = getSubpath(importSpecifier, packageRootSpecifier);
+                if (!importSubpath) {
+                    return;
+                }
+                const resolvedRootModuleFilePath = resolveTypescriptModule(packageRootSpecifier);
+                if (!resolvedRootModuleFilePath) {
+                    return;
+                }
+                const packageMarkerFilePath = pickPackageMarkerFile(resolvedRootModuleFilePath);
+                if (!packageMarkerFilePath) {
+                    return;
+                }
+                const packageDirectory = path.dirname(packageMarkerFilePath);
+                const indexFilePath = pickIndexFileInDirectory(packageDirectory);
+                if (!indexFilePath) {
+                    return;
+                }
+                const hasMatchingReExport = indexExportsSubpath(indexFilePath, importSubpath);
+                if (!hasMatchingReExport) {
+                    return;
                 }
+                context.report({
+                    data: {
+                        importPath: importSpecifier,
+                        suggestedImport: packageRootSpecifier,
+                    },
+                    messageId: 'deepImport',
+                    node: node.source,
+                });
             },
         };
     },
     defaultOptions: [],
     meta: {
         docs: {
-            description: 'Disallow deep imports from packages that expose an index.ts next to ng-package.json or package.json',
+            description: 'Disallow deep imports only when package root index.ts (or index.d.ts) re-exports that subpath, and the package is marked by ng-package.json or package.json',
         },
         messages: {
-            deepImport: 'Import "{{importPath}}" should go through the package index.ts (use "{{suggestedImport}}").',
+            deepImport: 'Import "{{importPath}}" should go through the package root export (use "{{suggestedImport}}").',
         },
         schema: [],
         type: 'problem',
     },
     name: 'no-deep-imports-to-indexed-packages',
 });
+function isExternalModuleSpecifier(moduleSpecifier) {
+    if (!moduleSpecifier || moduleSpecifier.startsWith('.')) {
+        return false;
+    }
+    return !path.isAbsolute(moduleSpecifier);
+}
+function pickPackageMarkerFile(resolvedRootFilePath) {
+    const resolvedRootDirectory = path.dirname(resolvedRootFilePath);
+    const nearestNgPackageJson = findNearestFileUpwards(resolvedRootDirectory, 'ng-package.json');
+    const nearestPackageJson = findNearestFileUpwards(resolvedRootDirectory, 'package.json');
+    return nearestNgPackageJson ?? nearestPackageJson ?? null;
+}
+function pickIndexFileInDirectory(packageDirectory) {
+    const indexTypescriptPath = path.join(packageDirectory, 'index.ts');
+    const indexTypesDeclarationPath = path.join(packageDirectory, 'index.d.ts');
+    if (fs.existsSync(indexTypescriptPath)) {
+        return indexTypescriptPath;
+    }
+    if (fs.existsSync(indexTypesDeclarationPath)) {
+        return indexTypesDeclarationPath;
+    }
+    return null;
+}
+function isScopedPackage(importSpecifier) {
+    return importSpecifier.startsWith('@');
+}
+function getPackageRootSpecifier(importSpecifier) {
+    const pathParts = importSpecifier.split('/');
+    if (isScopedPackage(importSpecifier)) {
+        if (pathParts.length >= 2) {
+            return `${pathParts[0]}/${pathParts[1]}`;
+        }
+        return importSpecifier;
+    }
+    return pathParts[0] ?? importSpecifier;
+}
+function getSubpath(importSpecifier, packageRootSpecifier) {
+    if (importSpecifier === packageRootSpecifier) {
+        return null;
+    }
+    if (!importSpecifier.startsWith(`${packageRootSpecifier}/`)) {
+        return null;
+    }
+    return importSpecifier.slice(packageRootSpecifier.length + 1);
+}
+function findNearestFileUpwards(startDirectory, fileName) {
+    let currentDirectory = startDirectory;
+    while (currentDirectory.length > 0) {
+        const candidatePath = path.join(currentDirectory, fileName);
+        if (fs.existsSync(candidatePath)) {
+            return candidatePath;
+        }
+        const parentDirectory = path.dirname(currentDirectory);
+        if (parentDirectory === currentDirectory) {
+            break;
+        }
+        currentDirectory = parentDirectory;
+    }
+    return null;
+}
+function normalizeModuleSpecifier(moduleSpecifier) {
+    return moduleSpecifier.replaceAll('\\', '/');
+}
+function stripKnownExtensions(filePathOrSpecifier) {
+    return filePathOrSpecifier.replace(/\.(d\.ts|ts|tsx|js|jsx|mjs|cjs)$/, '');
+}
+function indexExportsSubpath(indexFilePath, subpath) {
+    const fileText = fs.readFileSync(indexFilePath, 'utf8');
+    const sourceFile = ts.createSourceFile(indexFilePath, fileText, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
+    const expectedSpecifier = normalizeModuleSpecifier(stripKnownExtensions(`./${subpath}`));
+    const expectedIndexSpecifier = normalizeModuleSpecifier(stripKnownExtensions(`./${subpath}/index`));
+    let isReExportFound = false;
+    sourceFile.forEachChild((astNode) => {
+        if (isReExportFound) {
+            return;
+        }
+        if (ts.isExportDeclaration(astNode)) {
+            const moduleSpecifierNode = astNode.moduleSpecifier;
+            if (moduleSpecifierNode && ts.isStringLiteral(moduleSpecifierNode)) {
+                const exportedSpecifier = normalizeModuleSpecifier(stripKnownExtensions(moduleSpecifierNode.text));
+                if (exportedSpecifier === expectedSpecifier ||
+                    exportedSpecifier === expectedIndexSpecifier) {
+                    isReExportFound = true;
+                }
+            }
+        }
+    });
+    return isReExportFound;
+}
 
 const MESSAGE_ID$2 = 'no-href-with-router-link';
 const ERROR_MESSAGE$1 = 'Do not use href and routerLink attributes together on the same element';

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "@taiga-ui/eslint-plugin-experience-next",
-  "version": "0.383.0",
+  "version": "0.384.0",
   "description": "An ESLint plugin to enforce a consistent code styles across taiga-ui projects",
   "license": "Apache-2.0",
   "type": "module",
   "devDependencies": {
-    "@typescript-eslint/rule-tester": "8.50.0",
+    "@typescript-eslint/rule-tester": "8.53.0",
     "glob": "13.0.0"
   },
   "peerDependencies": {
@@ -16,7 +16,7 @@
     "@smarttools/eslint-plugin-rxjs": "^1.0.22",
     "@stylistic/eslint-plugin": "^5.6.1",
     "@types/glob": "*",
-    "@typescript-eslint/eslint-plugin": "^8.50.0",
+    "@typescript-eslint/eslint-plugin": "^8.53.0",
     "angular-eslint": "^20.7.0",
     "eslint": "^9.39.2",
     "eslint-config-prettier": "^10.1.7",
@@ -28,7 +28,7 @@
     "eslint-plugin-jest": "^29.5.0",
     "eslint-plugin-package-json": "^0.85.0",
     "eslint-plugin-perfectionist": "^4.15.1",
-    "eslint-plugin-playwright": "^2.4.0",
+    "eslint-plugin-playwright": "^2.5.0",
     "eslint-plugin-prettier": "^5.5.4",
     "eslint-plugin-promise": "^7.2.1",
     "eslint-plugin-simple-import-sort": "^12.1.1",