@taiga-ui/eslint-plugin-experience-next 0.369.0 → 0.370.0

package/index.d.ts

@@ -28,7 +28,6 @@ declare const plugin: {
         'prefer-deep-imports': import("@typescript-eslint/utils/ts-eslint").RuleModule<"prefer-deep-imports", [{
             importFilter: string[] | string;
             strict?: boolean;
-            mockPaths?: Record<string, string>;
         }], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
         'short-tui-imports': import("@typescript-eslint/utils/ts-eslint").RuleModule<"replaceTuiImport", import("./rules/short-tui-imports").Options, unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
         'standalone-imports-sort': import("@typescript-eslint/utils/ts-eslint").RuleModule<"incorrectOrder", [{

package/index.esm.js

@@ -1930,37 +1930,63 @@ function getClass(node) {
 }
 
 const MESSAGE_ID$1 = 'prefer-deep-imports';
-const ERROR_MESSAGE = 'Import via root or non-leaf entry points is prohibited for this package';
+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 entryPointCache = new Map();
-const entryRootCache = new Map();
-const createRule$3 = ESLintUtils.RuleCreator((name) => name);
+const exportCheckCache = new Map();
+const nearestNgCache = new Map();
+const tsFileCache = new Map();
 var preferDeepImports = createRule$3({
-    create(context, [{ importFilter, mockPaths, strict = false }]) {
-        const selector = `ImportDeclaration[source.value=${getFilterRegExp(importFilter, strict)}]`;
+    create(context, [options]) {
+        const allowedPackages = normalizeFilter(options.importFilter);
+        const strict = options.strict ?? false;
         return {
-            [selector](node) {
-                const specifier = node.source.value;
-                const resolvedFile = resolveAlias(specifier, context, mockPaths);
-                if (!resolvedFile) {
+            ImportDeclaration(node) {
+                const importPath = node.source.value;
+                if (typeof importPath !== 'string') {
                     return;
                 }
-                const entryRoot = findEntryRoot(resolvedFile) ?? path.dirname(resolvedFile);
-                if (strict) {
-                    const nested = isNestedEntryPoint(specifier);
-                    const hasNested = checkNestedEntryPoints(entryRoot, mockPaths);
-                    if (nested && !hasNested) {
-                        return;
+                const shortName = extractPackageName(importPath);
+                const allowed = allowedPackages.some((pkg) => {
+                    if (shortName && pkg instanceof RegExp) {
+                        return pkg.test(shortName);
                     }
+                    return pkg === shortName;
+                });
+                if (!allowed) {
+                    return;
+                }
+                if (!strict && isNestedImport(importPath)) {
+                    return;
+                }
+                const symbols = extractImportedSymbols(node);
+                if (symbols.length === 0) {
+                    return;
+                }
+                const filename = context.filename;
+                const rootEntry = resolveRootEntryPoint(importPath, filename);
+                if (!rootEntry) {
+                    return context.report({
+                        messageId: MESSAGE_ID$1,
+                        node,
+                    });
+                }
+                const nested = findNestedEntryPoints(rootEntry);
+                if (nested.length === 0) {
+                    return context.report({
+                        messageId: MESSAGE_ID$1,
+                        node,
+                    });
                 }
-                const fixed = tryFixImport(node, entryRoot);
-                if (!fixed) {
-                    context.report({ messageId: MESSAGE_ID$1, node });
+                const symbolMap = mapSymbolsToEntryPoints(rootEntry, nested, symbols, strict);
+                if (symbolMap.size === 0) {
                     return;
                 }
+                const newImports = buildImports(node, importPath, symbolMap);
                 context.report({
                     fix(fixer) {
-                        return fixer.replaceTextRange([node.range[0], node.range[1]], fixed);
+                        return fixer.replaceTextRange(node.range, newImports);
                     },
                     messageId: MESSAGE_ID$1,
                     node,
@@ -1983,7 +2009,6 @@ var preferDeepImports = createRule$3({
                 additionalProperties: false,
                 properties: {
                     importFilter: { type: ['string', 'array'] },
-                    mockPaths: { type: 'object' },
                     strict: { type: 'boolean' },
                 },
                 type: 'object',
@@ -1993,140 +2018,244 @@ var preferDeepImports = createRule$3({
     },
     name: 'prefer-deep-imports',
 });
-function resolveAlias(specifier, context, mockPaths) {
-    if (mockPaths && specifier in mockPaths) {
-        return mockPaths[specifier] ?? null;
+function extractPackageName(importPath) {
+    if (!importPath.startsWith('@')) {
+        return null;
     }
-    if (moduleResolutionCache.has(specifier)) {
-        return moduleResolutionCache.get(specifier);
+    const p = importPath.split('/');
+    return p.length >= 2 ? `${p[0]}/${p[1]}` : null;
+}
+function isNestedImport(importPath) {
+    return importPath.split('/').length > 2;
+}
+function extractImportedSymbols(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);
+}
+function resolveRootEntryPoint(importPath, fromFile) {
+    const key = `${importPath}|${fromFile}`;
+    if (moduleResolutionCache.has(key)) {
+        return moduleResolutionCache.get(key);
     }
-    let result;
-    try {
-        const services = ESLintUtils.getParserServices(context);
-        const program = services.program;
-        const compilerOptions = program.getCompilerOptions();
-        const resolved = ts.resolveModuleName(specifier, context.filename, compilerOptions, ts.sys);
-        result = resolved.resolvedModule?.resolvedFileName ?? null;
+    const tsconfig = findNearestTsconfig(fromFile);
+    if (!tsconfig) {
+        moduleResolutionCache.set(key, null);
+        return null;
     }
-    catch {
-        result = 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);
     }
-    moduleResolutionCache.set(specifier, result);
-    return result;
-}
-function getImportedName$1(node) {
-    return node.type === AST_NODE_TYPES$1.Identifier ? node.name : node.value;
+    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;
 }
-function tryFixImport(node, entryRoot) {
-    const specifiers = node.specifiers;
-    const isTypeOnly = node.importKind === 'type';
-    const allTsFiles = globSync(`${entryRoot}/**/*.ts`, {
-        ignore: { ignored: (p) => /\.(spec|cy)\.ts$/.test(p.name) },
-    });
-    const sourceFiles = specifiers.map((sp) => {
-        if (sp.type !== AST_NODE_TYPES$1.ImportSpecifier) {
-            return null;
+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;
         }
-        const importedName = getImportedName$1(sp.imported);
-        const found = allTsFiles.find((filePath) => {
-            const content = fs.readFileSync(filePath, 'utf8');
-            const regExp = new RegExp(String.raw `(?<=export\s(default\s)?(abstract\s)?\w+\s)\b${importedName}\b`);
-            return regExp.test(content);
-        });
-        return found?.replaceAll(/\\+/g, '/');
-    });
-    if (sourceFiles.some((x) => !x)) {
-        return null;
+        const parent = path.dirname(dir);
+        if (parent === dir) {
+            break;
+        }
+        dir = parent;
     }
-    const entryPoints = sourceFiles.map(findNearestEntryPoint);
-    if (entryPoints.some((x) => !x)) {
-        return null;
+    return null;
+}
+function findNestedEntryPoints(root) {
+    const cached = tsFileCache.get(`${root}|ng`);
+    if (cached) {
+        return cached;
     }
-    const newImports = specifiers.map((sp, i) => {
-        if (sp.type !== AST_NODE_TYPES$1.ImportSpecifier) {
-            return null;
+    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;
+}
+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;
+        }
+        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);
+        }
+        for (const file of files) {
+            const content = safeReadFile(file);
+            if (!content) {
+                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);
+            }
         }
-        const imported = getImportedName$1(sp.imported);
-        const local = sp.local.name;
-        const mapped = imported === local ? imported : `${imported} as ${local}`;
-        return `import ${isTypeOnly ? 'type ' : ''}{${mapped}} from '${entryPoints[i]}';`;
-    });
-    if (newImports.some((x) => x === null)) {
-        return null;
     }
-    return newImports.join('\n');
+    return result;
 }
-function findEntryRoot(resolvedFile) {
-    if (entryRootCache.has(resolvedFile)) {
-        return entryRootCache.get(resolvedFile);
+function cachedContainsDirectExport(file, content, symbol) {
+    let cache = exportCheckCache.get(file);
+    if (!cache) {
+        cache = new Map();
+        exportCheckCache.set(file, cache);
     }
-    let dir = path.dirname(resolvedFile);
-    while (dir !== path.dirname(dir)) {
-        if (fs.existsSync(path.join(dir, 'ng-package.json'))) {
-            entryRootCache.set(resolvedFile, dir);
-            return dir;
-        }
-        dir = path.dirname(dir);
+    const key = `direct:${symbol}`;
+    if (cache.has(key)) {
+        return cache.get(key);
     }
-    entryRootCache.set(resolvedFile, null);
-    return null;
+    const res = containsDirectExport(content, symbol);
+    cache.set(key, res);
+    return res;
 }
-function findNearestEntryPoint(filePath) {
-    if (!filePath) {
-        return '';
+function cachedContainsReExport(file, content, symbol) {
+    let cache = exportCheckCache.get(file);
+    if (!cache) {
+        cache = new Map();
+        exportCheckCache.set(file, cache);
     }
-    const parts = filePath.split('/');
-    for (let i = parts.length - 1; i >= 0; i--) {
-        const candidate = parts.slice(0, i).join('/');
-        if (fs.existsSync(`${candidate}/ng-package.json`)) {
-            return candidate;
-        }
+    const key = `re:${symbol}`;
+    if (cache.has(key)) {
+        return cache.get(key);
     }
-    return '';
+    const res = containsReExport(file, content, symbol);
+    cache.set(key, res);
+    return res;
 }
-function checkNestedEntryPoints(entryRoot, mockPaths) {
-    if (mockPaths && Object.keys(mockPaths).length > 0) {
-        const normRoot = entryRoot.replaceAll('\\', '/').replace(/\/+$/, '');
-        const hasNestedMock = Object.values(mockPaths).some((resolved) => {
-            const dir = path.dirname(resolved).replaceAll('\\', '/');
-            return dir.startsWith(`${normRoot}/`) && dir !== normRoot;
-        });
-        if (hasNestedMock) {
+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);
+}
+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;
         }
     }
-    if (entryPointCache.has(entryRoot)) {
-        return entryPointCache.get(entryRoot);
+    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;
+        }
+        const nested = safeReadFile(resolved);
+        if (nested && containsDirectExport(nested, symbol)) {
+            return true;
+        }
     }
-    const nested = globSync(`${entryRoot}/**/ng-package.json`).map((path) => path.replaceAll(/\\+/g, '/'));
-    const hasNested = nested.some((path) => path !== `${entryRoot}/ng-package.json`);
-    entryPointCache.set(entryRoot, hasNested);
-    return hasNested;
+    return false;
 }
-function isNestedEntryPoint(specifier) {
-    const segments = specifier.split('/');
-    return specifier.startsWith('@') ? segments.length > 2 : segments.length > 1;
+function resolveReExport(file, rel) {
+    const full = path.resolve(path.dirname(file), rel);
+    return fs.existsSync(full) ? full : null;
 }
-function getFilterRegExp(filter, strict) {
-    if (typeof filter === 'string' && filter.startsWith('/')) {
-        return strict ? extendRegExp(filter) : filter;
+function cachedNearestNg(file, root) {
+    const key = `${file}|${root}`;
+    if (nearestNgCache.has(key)) {
+        return nearestNgCache.get(key);
     }
-    const packages = typeof filter === 'string' ? [filter] : filter;
-    const [npmScope] = packages[0]?.split('/') ?? [];
-    const names = packages.map((p) => p.split('/')[1]).filter(Boolean);
-    const base = String.raw `/^${npmScope}\u002F(${names.join('|')})$/`;
-    return strict ? extendRegExp(base) : base;
+    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 extendRegExp(regExp) {
-    const trimmed = regExp.trim();
-    const slash = trimmed.lastIndexOf('/');
-    if (!trimmed.startsWith('/') || slash <= 1) {
-        return regExp;
+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, []);
+        }
+        groups.get(target).push(symbol);
+    }
+    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 local = sp.local.name;
+            return symbol === local ? symbol : `${symbol} as ${local}`;
+        });
+        result.push(`import ${isTypeOnly ? 'type ' : ''}{${importParts.join(', ')}} from '${target}';`);
     }
-    const flags = trimmed.slice(slash + 1);
-    const pattern = trimmed.slice(1, slash);
-    const strictPattern = String.raw `${pattern.replace(/\$$/, '')}(?:\u002F.*)?$`;
-    return `/${strictPattern}/${flags}`;
+    return result.join('\n');
+}
+function safeReadFile(file) {
+    try {
+        return fs.readFileSync(file, 'utf8');
+    }
+    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;
+    });
 }
 
 function getImportedName(spec) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@taiga-ui/eslint-plugin-experience-next",
-  "version": "0.369.0",
+  "version": "0.370.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,10 +1,9 @@
 import { ESLintUtils } from '@typescript-eslint/utils';
-type Options = [
+type RuleOptions = [
     {
         importFilter: string[] | string;
         strict?: boolean;
-        mockPaths?: Record<string, string>;
     }
 ];
-declare const _default: ESLintUtils.RuleModule<"prefer-deep-imports", Options, unknown, ESLintUtils.RuleListener>;
+declare const _default: ESLintUtils.RuleModule<"prefer-deep-imports", RuleOptions, unknown, ESLintUtils.RuleListener>;
 export default _default;