@taiga-ui/eslint-plugin-experience-next 0.372.0 → 0.373.0

package/index.esm.js

@@ -1135,7 +1135,7 @@ function projectJsonExist(filename) {
 }
 
 const allPackageJSONs = globSync('**/package.json', {
-    ignore: ['node_modules/**', 'dist/**'],
+    ignore: ['**/node_modules/**', '**/dist/**'],
 }).filter((path) => !readJSON(path).private);
 const packageNames = allPackageJSONs.map((path) => readJSON(path).name).filter(Boolean);
 const packageSourceGlobs = allPackageJSONs.map((p) => p.replaceAll(/\\+/g, '/').replace('package.json', '**/*.ts'));
@@ -1932,61 +1932,63 @@ function getClass(node) {
 const MESSAGE_ID$1 = 'prefer-deep-imports';
 const ERROR_MESSAGE = 'Import via root entry point is prohibited when nested entry points exist';
 const createRule$3 = ESLintUtils.RuleCreator(() => ERROR_MESSAGE);
-const tsconfigCache = new Map();
-const moduleResolutionCache = new Map();
-const exportCheckCache = new Map();
-const nearestNgCache = new Map();
-const tsFileCache = new Map();
 var preferDeepImports = createRule$3({
     create(context, [options]) {
-        const allowedPackages = normalizeFilter(options.importFilter);
-        const strict = options.strict ?? false;
+        const allowedPackages = normalizeImportFilter(options.importFilter);
+        const isStrictMode = options.strict ?? false;
+        const parserServices = ESLintUtils.getParserServices(context);
+        const program = parserServices.program;
+        const typeChecker = program.getTypeChecker();
         return {
             ImportDeclaration(node) {
-                const importPath = node.source.value;
-                if (typeof importPath !== 'string') {
+                const rawImportPath = node.source.value;
+                if (typeof rawImportPath !== 'string') {
                     return;
                 }
-                const shortName = extractPackageName(importPath);
-                const allowed = allowedPackages.some((pkg) => {
-                    if (shortName && pkg instanceof RegExp) {
-                        return pkg.test(shortName);
-                    }
-                    return pkg === shortName;
-                });
-                if (!allowed) {
+                const rootPackageName = getRootPackageName(rawImportPath);
+                if (!rootPackageName) {
+                    return;
+                }
+                if (!allowedPackages.includes(rootPackageName)) {
                     return;
                 }
-                if (!strict && isNestedImport(importPath)) {
+                if (!isStrictMode &&
+                    isAlreadyNestedImport(rawImportPath, rootPackageName)) {
                     return;
                 }
-                const symbols = extractImportedSymbols(node);
-                if (symbols.length === 0) {
+                const importedSymbols = extractNamedImportedSymbols(node);
+                if (importedSymbols.length === 0) {
                     return;
                 }
-                const filename = context.filename;
-                const rootEntry = resolveRootEntryPoint(importPath, filename);
-                if (!rootEntry) {
-                    return context.report({
+                const currentFileName = context.getFilename();
+                const rootEntryDirectory = resolveRootEntryDirectory(rawImportPath, currentFileName, program);
+                if (!rootEntryDirectory) {
+                    context.report({
                         messageId: MESSAGE_ID$1,
                         node,
                     });
+                    return;
                 }
-                const nested = findNestedEntryPoints(rootEntry);
-                if (nested.length === 0) {
-                    return context.report({
+                const nestedEntryPointRelativePaths = findNestedEntryPointRelativePaths(rootEntryDirectory);
+                if (nestedEntryPointRelativePaths.length === 0) {
+                    context.report({
                         messageId: MESSAGE_ID$1,
                         node,
                     });
+                    return;
+                }
+                const candidateEntryPointPaths = selectCandidateEntryPointsForMode(nestedEntryPointRelativePaths, isStrictMode);
+                if (candidateEntryPointPaths.length === 0) {
+                    return;
                 }
-                const symbolMap = mapSymbolsToEntryPoints(rootEntry, nested, symbols, strict);
-                if (symbolMap.size === 0) {
+                const symbolToEntryPoint = mapSymbolsToEntryPointsUsingTypeChecker(importedSymbols, candidateEntryPointPaths, rootEntryDirectory, program, typeChecker);
+                if (symbolToEntryPoint.size === 0) {
                     return;
                 }
-                const newImports = buildImports(node, importPath, symbolMap);
+                const newImportBlock = buildRewrittenImports(node, rawImportPath, symbolToEntryPoint);
                 context.report({
                     fix(fixer) {
-                        return fixer.replaceTextRange(node.range, newImports);
+                        return fixer.replaceTextRange(node.range, newImportBlock);
                     },
                     messageId: MESSAGE_ID$1,
                     node,
@@ -2018,244 +2020,264 @@ var preferDeepImports = createRule$3({
     },
     name: 'prefer-deep-imports',
 });
-function extractPackageName(importPath) {
-    if (!importPath.startsWith('@')) {
-        return null;
+/**
+ * Normalize "importFilter" option to a flat array of package names.
+ * The rule expects concrete package names, not regular expression strings.
+ */
+function normalizeImportFilter(importFilter) {
+    return Array.isArray(importFilter) ? importFilter : [importFilter];
+}
+/**
+ * Extract the package root name from an import specifier.
+ *
+ * Examples:
+ *  "@taiga-ui/core"               → "@taiga-ui/core"
+ *  "@taiga-ui/core/components"   → "@taiga-ui/core"
+ *  "some-lib"                    → "some-lib"
+ *  "some-lib/utils"              → "some-lib"
+ */
+function getRootPackageName(importPath) {
+    if (importPath.startsWith('@')) {
+        const segments = importPath.split('/');
+        if (segments.length < 2) {
+            return null;
+        }
+        return `${segments[0]}/${segments[1]}`;
     }
-    const p = importPath.split('/');
-    return p.length >= 2 ? `${p[0]}/${p[1]}` : null;
+    const parts = importPath.split('/');
+    return parts[0] ?? null;
 }
-function isNestedImport(importPath) {
-    return importPath.split('/').length > 2;
+/**
+ * Check whether the current import path is already nested below the root package.
+ *
+ * Example:
+ *   root = "@taiga-ui/core"
+ *   "@taiga-ui/core"               → false (root import)
+ *   "@taiga-ui/core/components"    → true
+ *   "@taiga-ui/core/components/x"  → true
+ */
+function isAlreadyNestedImport(importPath, rootPackageName) {
+    if (!importPath.startsWith(rootPackageName)) {
+        return false;
+    }
+    const importSegments = importPath.split('/');
+    const rootSegments = rootPackageName.split('/');
+    return importSegments.length > rootSegments.length;
 }
-function extractImportedSymbols(node) {
+/**
+ * Extract only named imported symbols:
+ *
+ * Examples:
+ *   import {A, B as C} from 'x';  → ['A', 'B']
+ *
+ * Namespace imports and default imports are ignored for this rule.
+ */
+function extractNamedImportedSymbols(node) {
     return node.specifiers
-        .filter((s) => s.type === AST_NODE_TYPES$1.ImportSpecifier)
-        .map((s) => s.imported.type === AST_NODE_TYPES$1.Identifier
-        ? s.imported.name
-        : s.imported.value);
+        .filter((specifier) => specifier.type === AST_NODE_TYPES$1.ImportSpecifier)
+        .map((specifier) => specifier.imported.type === AST_NODE_TYPES$1.Identifier
+        ? specifier.imported.name
+        : specifier.imported.value);
 }
-function resolveRootEntryPoint(importPath, fromFile) {
-    const key = `${importPath}|${fromFile}`;
-    if (moduleResolutionCache.has(key)) {
-        return moduleResolutionCache.get(key);
-    }
-    const tsconfig = findNearestTsconfig(fromFile);
-    if (!tsconfig) {
-        moduleResolutionCache.set(key, null);
+/**
+ * Resolve the physical directory of the module being imported.
+ * We rely on the same module resolution that TypeScript uses for the program.
+ */
+function resolveRootEntryDirectory(importPath, fromFile, program) {
+    const compilerOptions = program.getCompilerOptions();
+    const resolution = ts.resolveModuleName(importPath, fromFile, compilerOptions, ts.sys).resolvedModule;
+    if (!resolution) {
         return null;
     }
-    let parsed = tsconfigCache.get(tsconfig);
-    if (!parsed) {
-        const json = ts.readConfigFile(tsconfig, ts.sys.readFile).config;
-        parsed = ts.parseJsonConfigFileContent(json, ts.sys, path.dirname(tsconfig));
-        tsconfigCache.set(tsconfig, parsed);
-    }
-    const resolved = ts.resolveModuleName(importPath, fromFile, parsed.options, ts.sys).resolvedModule;
-    const value = resolved ? path.dirname(resolved.resolvedFileName) : null;
-    moduleResolutionCache.set(key, value);
-    return value;
+    return path.dirname(resolution.resolvedFileName);
 }
-function findNearestTsconfig(start) {
-    let dir = path.dirname(start);
-    const limit = process.cwd();
-    while (dir.startsWith(limit)) {
-        const candidate = path.join(dir, 'tsconfig.json');
-        if (fs.existsSync(candidate)) {
-            return candidate;
+/**
+ * Find all nested entry points relative to the given root directory.
+ *
+ * A directory is considered a nested entry point if it contains either:
+ *   - "ng-package.json"  (Angular library entry)
+ *   - "collection.json"  (Angular schematics collection)
+ *
+ * Returned paths are relative to "rootEntryDirectory".
+ *
+ * Example:
+ *   rootEntryDirectory = ".../core/src"
+ *   found:
+ *     "utils/ng-package.json"          → "utils"
+ *     "utils/dom/ng-package.json"      → "utils/dom"
+ *     "schematics/collection.json"     → "schematics"
+ */
+function findNestedEntryPointRelativePaths(rootEntryDirectory) {
+    const ngPackageJsonFiles = globSync('**/ng-package.json', {
+        absolute: false,
+        cwd: rootEntryDirectory,
+    });
+    const collectionJsonFiles = globSync('**/collection.json', {
+        absolute: false,
+        cwd: rootEntryDirectory,
+    });
+    const directories = [];
+    for (const file of ngPackageJsonFiles) {
+        const normalized = file.replaceAll('\\', '/').replace(/\/ng-package\.json$/, '');
+        if (normalized && normalized !== '.') {
+            directories.push(normalized);
         }
-        const parent = path.dirname(dir);
-        if (parent === dir) {
-            break;
+    }
+    for (const file of collectionJsonFiles) {
+        const normalized = file.replaceAll('\\', '/').replace(/\/collection\.json$/, '');
+        if (normalized && normalized !== '.') {
+            directories.push(normalized);
         }
-        dir = parent;
     }
-    return null;
+    return directories;
 }
-function findNestedEntryPoints(root) {
-    const cached = tsFileCache.get(`${root}|ng`);
-    if (cached) {
-        return cached;
+/**
+ * For strict = false:
+ *   Only first-level nested directories are candidates.
+ *
+ * For strict = true:
+ *   All nested directories are candidates, sorted from deepest to shallowest
+ *   so that the deepest match wins.
+ */
+function selectCandidateEntryPointsForMode(allNestedRelativePaths, strict) {
+    if (!strict) {
+        return allNestedRelativePaths.filter((relativePath) => !relativePath.includes('/'));
     }
-    const found = globSync('**/ng-package.json', { absolute: false, cwd: root })
-        .map((p) => p.replaceAll('\\', '/'))
-        .map((p) => p.replace('/ng-package.json', ''))
-        .filter((dir) => dir !== '.');
-    tsFileCache.set(`${root}|ng`, found);
-    return found;
+    return [...allNestedRelativePaths].sort((a, b) => {
+        const depthA = a.split('/').filter(Boolean).length;
+        const depthB = b.split('/').filter(Boolean).length;
+        return depthB - depthA;
+    });
 }
-function mapSymbolsToEntryPoints(root, nested, symbols, strict) {
-    const result = new Map();
-    const remaining = new Set(symbols);
-    for (const np of nested) {
-        if (remaining.size === 0) {
-            break;
+/**
+ * Build a map from exported symbol name to nested entry point relative path.
+ *
+ * Implementation strategy:
+ *   1. For each candidate nested entry point:
+ *      - Determine its entry file (using ng-package.json or collection.json).
+ *      - Ask TypeScript for the module symbol and its exports.
+ *   2. For each imported symbol:
+ *      - Find the first entry point whose export table contains that symbol.
+ *      - strict = true: candidates were sorted deepest-first.
+ *      - strict = false: candidates contain only first-level nested entry points.
+ */
+function mapSymbolsToEntryPointsUsingTypeChecker(importedSymbols, candidateEntryPoints, rootEntryDirectory, program, typeChecker) {
+    const symbolToEntryPoint = new Map();
+    const exportTableByEntryPoint = new Map();
+    for (const relativeEntryDir of candidateEntryPoints) {
+        const entryFile = getEntryFileForNestedEntryPoint(rootEntryDirectory, relativeEntryDir);
+        if (!entryFile) {
+            continue;
         }
-        const full = path.join(root, np);
-        let files = tsFileCache.get(full);
-        if (!files) {
-            files = globSync('**/*.ts', {
-                absolute: true,
-                cwd: full,
-                ignore: ['**/*.spec.ts', '**/*.cy.ts'],
-            });
-            tsFileCache.set(full, files);
+        const sourceFile = program.getSourceFile(entryFile);
+        if (!sourceFile) {
+            continue;
         }
-        for (const file of files) {
-            const content = safeReadFile(file);
-            if (!content) {
+        const moduleSymbol = typeChecker.getSymbolAtLocation(sourceFile);
+        if (!moduleSymbol) {
+            continue;
+        }
+        const exports$1 = typeChecker.getExportsOfModule(moduleSymbol);
+        const exportedNames = new Set(exports$1.map((symbol) => symbol.getName()));
+        exportTableByEntryPoint.set(relativeEntryDir, exportedNames);
+    }
+    for (const importedSymbol of importedSymbols) {
+        for (const relativeEntryDir of candidateEntryPoints) {
+            const exportedNames = exportTableByEntryPoint.get(relativeEntryDir);
+            if (!exportedNames) {
                 continue;
             }
-            for (const symbol of Array.from(remaining)) {
-                const has = cachedContainsDirectExport(file, content, symbol) ||
-                    cachedContainsReExport(file, content, symbol);
-                if (!has) {
-                    continue;
-                }
-                const nearest = cachedNearestNg(file, root);
-                if (!nearest) {
-                    continue;
-                }
-                let suffix = path.relative(root, nearest).replaceAll('\\', '/');
-                if (!strict && suffix.includes('/')) {
-                    suffix = suffix.split('/')[0];
-                }
-                result.set(symbol, suffix);
-                remaining.delete(symbol);
+            if (!exportedNames.has(importedSymbol)) {
+                continue;
             }
+            symbolToEntryPoint.set(importedSymbol, relativeEntryDir);
+            break;
         }
     }
-    return result;
-}
-function cachedContainsDirectExport(file, content, symbol) {
-    let cache = exportCheckCache.get(file);
-    if (!cache) {
-        cache = new Map();
-        exportCheckCache.set(file, cache);
-    }
-    const key = `direct:${symbol}`;
-    if (cache.has(key)) {
-        return cache.get(key);
-    }
-    const res = containsDirectExport(content, symbol);
-    cache.set(key, res);
-    return res;
-}
-function cachedContainsReExport(file, content, symbol) {
-    let cache = exportCheckCache.get(file);
-    if (!cache) {
-        cache = new Map();
-        exportCheckCache.set(file, cache);
-    }
-    const key = `re:${symbol}`;
-    if (cache.has(key)) {
-        return cache.get(key);
-    }
-    const res = containsReExport(file, content, symbol);
-    cache.set(key, res);
-    return res;
-}
-function containsDirectExport(content, symbol) {
-    const re = new RegExp(String.raw `(?:export\s+(?:function|class|const|let|var)\s+${symbol}\b)|` +
-        String.raw `(?:export\s*\{[^}]*\b${symbol}\b[^}]*\})`);
-    return re.test(content);
+    return symbolToEntryPoint;
 }
-function containsReExport(file, content, symbol) {
-    const star = /export\s*\*\s*from\s*['"](.+)['"]/g;
-    let m;
-    while ((m = star.exec(content))) {
-        const resolved = resolveReExport(file, m[1]);
-        if (!resolved) {
-            continue;
-        }
-        const nested = safeReadFile(resolved);
-        if (nested && containsDirectExport(nested, symbol)) {
-            return true;
-        }
-    }
-    const named = new RegExp(String.raw `export\s*\{[^}]*\b${symbol}\b[^}]*\}\s*from\s*['"](.+)['"]`);
-    const nm = named.exec(content);
-    if (nm) {
-        const resolved = resolveReExport(file, nm[1]);
-        if (!resolved) {
-            return false;
+/**
+ * Determine the physical entry file for a nested entry point.
+ *
+ * Priority:
+ *   1. If "ng-package.json" exists:
+ *        - use lib.entryFile if present
+ *        - otherwise fall back to "index.ts"
+ *   2. Else if "collection.json" exists:
+ *        - treat this directory as a schematic collection package
+ *        - entry file is "index.ts" if it exists
+ *   3. Otherwise: no entry file can be determined → return null
+ */
+function getEntryFileForNestedEntryPoint(rootEntryDirectory, relativeEntryDirectory) {
+    const absoluteDirectory = path.join(rootEntryDirectory, relativeEntryDirectory);
+    const ngPackageJsonPath = path.join(absoluteDirectory, 'ng-package.json');
+    const collectionJsonPath = path.join(absoluteDirectory, 'collection.json');
+    if (fs.existsSync(ngPackageJsonPath)) {
+        try {
+            const raw = fs.readFileSync(ngPackageJsonPath, 'utf8');
+            const json = JSON.parse(raw);
+            const entryRelative = json.lib?.entryFile ?? 'index.ts';
+            return path.resolve(absoluteDirectory, entryRelative);
         }
-        const nested = safeReadFile(resolved);
-        if (nested && containsDirectExport(nested, symbol)) {
-            return true;
+        catch {
+            const fallback = path.resolve(absoluteDirectory, 'index.ts');
+            return fs.existsSync(fallback) ? fallback : null;
         }
     }
-    return false;
-}
-function resolveReExport(file, rel) {
-    const full = path.resolve(path.dirname(file), rel);
-    return fs.existsSync(full) ? full : null;
-}
-function cachedNearestNg(file, root) {
-    const key = `${file}|${root}`;
-    if (nearestNgCache.has(key)) {
-        return nearestNgCache.get(key);
+    if (fs.existsSync(collectionJsonPath)) {
+        const entryFile = path.resolve(absoluteDirectory, 'index.ts');
+        return fs.existsSync(entryFile) ? entryFile : null;
     }
-    let dir = path.dirname(file);
-    while (dir.startsWith(root)) {
-        const candidate = path.join(dir, 'ng-package.json');
-        if (fs.existsSync(candidate)) {
-            nearestNgCache.set(key, dir);
-            return dir;
-        }
-        const parent = path.dirname(dir);
-        if (parent === dir) {
-            break;
-        }
-        dir = parent;
-    }
-    nearestNgCache.set(key, null);
     return null;
 }
-function buildImports(node, baseImport, symbolMap) {
-    const isTypeOnly = node.importKind === 'type';
-    const groups = new Map();
-    for (const [symbol, suffix] of symbolMap.entries()) {
-        const target = suffix ? `${baseImport}/${suffix}` : baseImport;
-        if (!groups.has(target)) {
-            groups.set(target, []);
+/**
+ * Build the final text block with rewritten import declarations.
+ *
+ * Example:
+ *   original:
+ *     import {A, B as C, D} from '@taiga-ui/core';
+ *
+ *   symbolMap (strict = true):
+ *     A -> "components/button"
+ *     B -> "components/button"
+ *     D -> "components/other"
+ *
+ *   result:
+ *     import {A, B as C} from '@taiga-ui/core/components/button';
+ *     import {D} from '@taiga-ui/core/components/other';
+ */
+function buildRewrittenImports(node, baseImportPath, symbolToEntryPoint) {
+    const isTypeOnlyImport = node.importKind === 'type';
+    const groupedByTarget = new Map();
+    for (const [symbolName, relativeEntryPath] of symbolToEntryPoint.entries()) {
+        const targetSpecifier = `${baseImportPath}/${relativeEntryPath}`;
+        if (!groupedByTarget.has(targetSpecifier)) {
+            groupedByTarget.set(targetSpecifier, []);
         }
-        groups.get(target).push(symbol);
+        groupedByTarget.get(targetSpecifier).push(symbolName);
     }
-    const result = [];
-    for (const [target, symbols] of groups.entries()) {
-        const importParts = symbols.map((symbol) => {
-            const sp = node.specifiers.find((s) => s.type === AST_NODE_TYPES$1.ImportSpecifier &&
-                (s.imported.type === AST_NODE_TYPES$1.Identifier
-                    ? s.imported.name === symbol
-                    : s.imported.value === symbol));
-            if (!sp) {
-                return symbol;
+    const importStatements = [];
+    for (const [targetSpecifier, symbols] of groupedByTarget.entries()) {
+        const parts = symbols.map((symbolName) => {
+            const matchingSpecifier = node.specifiers.find((specifier) => specifier.type === AST_NODE_TYPES$1.ImportSpecifier &&
+                (specifier.imported.type === AST_NODE_TYPES$1.Identifier
+                    ? specifier.imported.name === symbolName
+                    : specifier.imported.value === symbolName));
+            if (!matchingSpecifier) {
+                return symbolName;
             }
-            const local = sp.local.name;
-            return symbol === local ? symbol : `${symbol} as ${local}`;
+            const importedName = matchingSpecifier.imported.type === AST_NODE_TYPES$1.Identifier
+                ? matchingSpecifier.imported.name
+                : matchingSpecifier.imported.value;
+            const localName = matchingSpecifier.local.name;
+            return importedName === localName
+                ? importedName
+                : `${importedName} as ${localName}`;
         });
-        result.push(`import ${isTypeOnly ? 'type ' : ''}{${importParts.join(', ')}} from '${target}';`);
-    }
-    return result.join('\n');
-}
-function safeReadFile(file) {
-    try {
-        return fs.readFileSync(file, 'utf8');
+        const statement = `import ${isTypeOnlyImport ? 'type ' : ''}{${parts.join(', ')}} from '${targetSpecifier}';`;
+        importStatements.push(statement);
     }
-    catch {
-        return null;
-    }
-}
-function normalizeFilter(filter) {
-    const arr = Array.isArray(filter) ? filter : [filter];
-    return arr.map((item) => {
-        if (typeof item === 'string' && item.startsWith('/') && item.endsWith('/')) {
-            const body = item.slice(1, -1);
-            return new RegExp(body);
-        }
-        return item;
-    });
+    return importStatements.join('\n');
 }
 
 function getImportedName(spec) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@taiga-ui/eslint-plugin-experience-next",
-  "version": "0.372.0",
+  "version": "0.373.0",
   "description": "An ESLint plugin to enforce a consistent code styles across taiga-ui projects",
   "license": "Apache-2.0",
   "type": "module",

package/rules/prefer-deep-imports.d.ts

@@ -1,7 +1,20 @@
 import { ESLintUtils } from '@typescript-eslint/utils';
 type RuleOptions = [
     {
+        /**
+         * List of package names for which this rule should be applied.
+         * Usually something like: ['@taiga-ui/core', '@taiga-ui/cdk', ...]
+         */
         importFilter: string[] | string;
+        /**
+         * strict = false:
+         *   - Only rewrite imports from the root package path
+         *   - Target only the first-level nested entry point (e.g. "@pkg/components")
+         *
+         * strict = true:
+         *   - May rewrite imports from nested paths as well
+         *   - Target the deepest nested entry point that actually exports the symbol
+         */
         strict?: boolean;
     }
 ];