@taiga-ui/eslint-plugin-experience-next 0.497.0 → 0.498.0

package/index.esm.js

@@ -252223,7 +252223,7 @@ function isImportsArrayProperty(property) {
     return isProperty && hasIdentifierKey && isArray(property.value);
 }
 
-function getImportedName(spec) {
+function getImportedName$1(spec) {
     if (spec.imported.type === dist$3.AST_NODE_TYPES.Identifier) {
         return spec.imported.name;
     }
@@ -252297,7 +252297,7 @@ const rule$8 = createRule({
                             const specifierNames = importDeclaration.specifiers
                                 .filter((clause) => clause.type === dist$3.AST_NODE_TYPES.ImportSpecifier &&
                                 clause.importKind !== 'type')
-                                .map((specifier) => getImportedName(specifier));
+                                .map((specifier) => getImportedName$1(specifier));
                             const nextNames = new Set(specifierNames);
                             nextNames.add(short);
                             if (shouldDeleteImport) {
@@ -252307,7 +252307,7 @@ const rule$8 = createRule({
                                 .filter((clause) => clause.type === dist$3.AST_NODE_TYPES.ImportSpecifier &&
                                 (clause.importKind === 'type' ||
                                     importDeclaration.importKind === 'type'))
-                                .map((specifier) => `type ${getImportedName(specifier)}`);
+                                .map((specifier) => `type ${getImportedName$1(specifier)}`);
                             const allNames = [...typeImports, ...[...nextNames].sort()];
                             const newImport = `import { ${allNames.join(', ')} } from '${module}';`;
                             const alreadyHasShort = imports.some((id) => id.name === short);
@@ -252338,7 +252338,7 @@ const rule$8 = createRule({
                     if (spec.type !== dist$3.AST_NODE_TYPES.ImportSpecifier) {
                         continue;
                     }
-                    const importedClass = getImportedName(spec);
+                    const importedClass = getImportedName$1(spec);
                     const matchesPattern = /^Tui[A-Z].*(?:Component|Directive)$/.test(importedClass) ||
                         exceptions.some((exception) => exception.from === importedClass);
                     if (matchesPattern) {
@@ -253078,13 +253078,31 @@ const rule$2 = createRule({
 
 const MESSAGE_ID = 'prefer-deep-imports';
 const ERROR_MESSAGE = 'Import via root entry point is prohibited when nested entry points exist';
+const sharedStateByProgram = new WeakMap();
 const rule$1 = createRule({
     create(context, [options]) {
-        const allowedPackages = normalizeImportFilter(options.importFilter);
+        const allowedPackages = new Set(normalizeImportFilter(options.importFilter));
+        if (allowedPackages.size === 0) {
+            return {};
+        }
         const isStrictMode = options.strict ?? false;
-        const parserServices = dist$3.ESLintUtils.getParserServices(context);
-        const program = parserServices.program;
-        const typeChecker = program.getTypeChecker();
+        let state = null;
+        function getState() {
+            if (state) {
+                return state;
+            }
+            const parserServices = dist$3.ESLintUtils.getParserServices(context);
+            const program = parserServices.program;
+            state = {
+                allowedPackages,
+                isStrictMode,
+                program,
+                shared: getSharedState(program),
+                sourceCode: context.sourceCode,
+                typeChecker: program.getTypeChecker(),
+            };
+            return state;
+        }
         return {
             ImportDeclaration(node) {
                 const rawImportPath = node.source.value;
@@ -253093,7 +253111,7 @@ const rule$1 = createRule({
                 }
                 const rootPackageName = getRootPackageName(rawImportPath);
                 if (!rootPackageName ||
-                    !allowedPackages.includes(rootPackageName) ||
+                    !allowedPackages.has(rootPackageName) ||
                     (!isStrictMode &&
                         isAlreadyNestedImport(rawImportPath, rootPackageName))) {
                     return;
@@ -253102,32 +253120,38 @@ const rule$1 = createRule({
                 if (importedSymbols.length === 0) {
                     return;
                 }
-                const currentFileName = context.getFilename();
-                const rootEntryDirectory = resolveRootEntryDirectory(rawImportPath, currentFileName, program);
+                const currentState = getState();
+                const rootEntryDirectory = getCachedRootEntryDirectory({
+                    fromFile: context.getFilename(),
+                    importPath: rawImportPath,
+                    state: currentState,
+                });
                 if (!rootEntryDirectory) {
-                    context.report({
-                        messageId: MESSAGE_ID,
-                        node,
-                    });
                     return;
                 }
-                const nestedEntryPointRelativePaths = findNestedEntryPointRelativePaths(rootEntryDirectory);
+                const nestedEntryPointRelativePaths = getCachedNestedEntryPointRelativePaths(rootEntryDirectory, currentState.shared.nestedEntryPointPathsByRoot);
                 if (nestedEntryPointRelativePaths.length === 0) {
-                    context.report({
-                        messageId: MESSAGE_ID,
-                        node,
-                    });
                     return;
                 }
-                const candidateEntryPointPaths = selectCandidateEntryPointsForMode(nestedEntryPointRelativePaths, isStrictMode);
+                const candidateEntryPointPaths = selectCandidateEntryPointsForMode(nestedEntryPointRelativePaths, currentState.isStrictMode);
                 if (candidateEntryPointPaths.length === 0) {
                     return;
                 }
-                const symbolToEntryPoint = mapSymbolsToEntryPointsUsingTypeChecker(importedSymbols, candidateEntryPointPaths, rootEntryDirectory, program, typeChecker);
+                const symbolToEntryPoint = mapSymbolsToEntryPointsUsingTypeChecker({
+                    candidateEntryPoints: candidateEntryPointPaths,
+                    importedSymbols,
+                    rootEntryDirectory,
+                    state: currentState,
+                });
                 if (symbolToEntryPoint.size === 0) {
                     return;
                 }
-                const newImportBlock = buildRewrittenImports(node, rawImportPath, symbolToEntryPoint);
+                const newImportBlock = buildRewrittenImports({
+                    baseImportPath: rawImportPath,
+                    node,
+                    state: currentState,
+                    symbolToEntryPoint,
+                });
                 context.report({
                     fix(fixer) {
                         return fixer.replaceTextRange(node.range, newImportBlock);
@@ -253152,7 +253176,15 @@ const rule$1 = createRule({
             {
                 additionalProperties: false,
                 properties: {
-                    importFilter: { type: ['string', 'array'] },
+                    importFilter: {
+                        oneOf: [
+                            { type: 'string' },
+                            {
+                                items: { type: 'string' },
+                                type: 'array',
+                            },
+                        ],
+                    },
                     strict: { type: 'boolean' },
                 },
                 type: 'object',
@@ -253162,22 +253194,22 @@ const rule$1 = createRule({
     },
     name: 'prefer-deep-imports',
 });
-/**
- * Normalize "importFilter" option to a flat array of package names.
- * The rule expects concrete package names, not regular expression strings.
- */
+function getSharedState(program) {
+    const cached = sharedStateByProgram.get(program);
+    if (cached) {
+        return cached;
+    }
+    const state = {
+        entryPointBySymbolCache: new Map(),
+        nestedEntryPointPathsByRoot: new Map(),
+        rootEntryDirectoryByImport: new Map(),
+    };
+    sharedStateByProgram.set(program, state);
+    return state;
+}
 function normalizeImportFilter(importFilter) {
-    return Array.isArray(importFilter) ? importFilter : [importFilter];
+    return (Array.isArray(importFilter) ? importFilter : [importFilter]).filter(Boolean);
 }
-/**
- * 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('/');
@@ -253189,15 +253221,6 @@ function getRootPackageName(importPath) {
     const parts = importPath.split('/');
     return parts[0] ?? null;
 }
-/**
- * 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;
@@ -253206,63 +253229,49 @@ function isAlreadyNestedImport(importPath, rootPackageName) {
     const rootSegments = rootPackageName.split('/');
     return importSegments.length > rootSegments.length;
 }
-/**
- * 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((specifier) => specifier.type === dist$2.AST_NODE_TYPES.ImportSpecifier)
-        .map((specifier) => specifier.imported.type === dist$2.AST_NODE_TYPES.Identifier
+        .map(getImportedName);
+}
+function getImportedName(specifier) {
+    return specifier.imported.type === dist$2.AST_NODE_TYPES.Identifier
         ? specifier.imported.name
-        : specifier.imported.value);
+        : specifier.imported.value;
+}
+function getCachedRootEntryDirectory({ fromFile, importPath, state, }) {
+    const cacheKey = `${path.dirname(fromFile)}\0${importPath}`;
+    const cache = state.shared.rootEntryDirectoryByImport;
+    if (cache.has(cacheKey)) {
+        return cache.get(cacheKey) ?? null;
+    }
+    const rootEntryDirectory = resolveRootEntryDirectory({
+        fromFile,
+        importPath,
+        program: state.program,
+    });
+    cache.set(cacheKey, rootEntryDirectory);
+    return rootEntryDirectory;
 }
-/**
- * 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;
+function resolveRootEntryDirectory({ fromFile, importPath, program, }) {
+    const resolution = ts.resolveModuleName(importPath, fromFile, program.getCompilerOptions(), ts.sys).resolvedModule;
+    return resolution ? path.dirname(resolution.resolvedFileName) : null;
+}
+function getCachedNestedEntryPointRelativePaths(rootEntryDirectory, cache) {
+    if (cache.has(rootEntryDirectory)) {
+        return cache.get(rootEntryDirectory) ?? [];
     }
-    return path.dirname(resolution.resolvedFileName);
+    const entryPoints = findNestedEntryPointRelativePaths(rootEntryDirectory);
+    cache.set(rootEntryDirectory, entryPoints);
+    return entryPoints;
 }
-/**
- * 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 files = ['**/ng-package.json', '**/collection.json'].flatMap((pattern) => globSync(pattern, { cwd: rootEntryDirectory }));
-    return files
-        .map((file) => path.dirname(file).replaceAll('\\', '/'))
+    const directories = files
+        .map((file) => path.posix.dirname(file.replaceAll('\\', '/')))
         .filter((directory) => directory && directory !== '.');
+    return [...new Set(directories)];
 }
-/**
- * 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('/'));
@@ -253273,62 +253282,70 @@ function selectCandidateEntryPointsForMode(allNestedRelativePaths, strict) {
         return depthB - depthA;
     });
 }
-/**
- * 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) {
+function mapSymbolsToEntryPointsUsingTypeChecker({ candidateEntryPoints, importedSymbols, rootEntryDirectory, state, }) {
     const symbolToEntryPoint = new Map();
-    const exportTableByEntryPoint = new Map();
-    for (const relativeEntryDir of candidateEntryPoints) {
-        const entryFile = getEntryFileForNestedEntryPoint(rootEntryDirectory, relativeEntryDir);
-        if (!entryFile) {
-            continue;
-        }
-        const sourceFile = program.getSourceFile(entryFile);
-        if (!sourceFile) {
-            continue;
+    const entryPointBySymbol = getCachedEntryPointBySymbol({
+        candidateEntryPoints,
+        rootEntryDirectory,
+        state,
+    });
+    for (const importedSymbol of importedSymbols) {
+        const entryPoint = entryPointBySymbol.get(importedSymbol);
+        if (entryPoint) {
+            symbolToEntryPoint.set(importedSymbol, entryPoint);
         }
-        const moduleSymbol = typeChecker.getSymbolAtLocation(sourceFile);
-        if (!moduleSymbol) {
+    }
+    return symbolToEntryPoint;
+}
+function getCachedEntryPointBySymbol({ candidateEntryPoints, rootEntryDirectory, state, }) {
+    const cacheKey = `${rootEntryDirectory}\0${candidateEntryPoints.join('\0')}`;
+    const cache = state.shared.entryPointBySymbolCache;
+    if (cache.has(cacheKey)) {
+        return cache.get(cacheKey) ?? new Map();
+    }
+    const entryPointBySymbol = buildEntryPointBySymbolIndex({
+        candidateEntryPoints,
+        rootEntryDirectory,
+        state,
+    });
+    cache.set(cacheKey, entryPointBySymbol);
+    return entryPointBySymbol;
+}
+function buildEntryPointBySymbolIndex({ candidateEntryPoints, rootEntryDirectory, state, }) {
+    const entryPointBySymbol = new Map();
+    for (const relativeEntryDir of candidateEntryPoints) {
+        const exportedNames = getExportedNamesForEntryPoint({
+            relativeEntryDirectory: relativeEntryDir,
+            rootEntryDirectory,
+            state,
+        });
+        if (!exportedNames) {
             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?.has(importedSymbol)) {
-                continue;
+        for (const exportedName of exportedNames) {
+            if (!entryPointBySymbol.has(exportedName)) {
+                entryPointBySymbol.set(exportedName, relativeEntryDir);
             }
-            symbolToEntryPoint.set(importedSymbol, relativeEntryDir);
-            break;
         }
     }
-    return symbolToEntryPoint;
+    return entryPointBySymbol;
+}
+function getExportedNamesForEntryPoint({ relativeEntryDirectory, rootEntryDirectory, state, }) {
+    const entryFile = getEntryFileForNestedEntryPoint(rootEntryDirectory, relativeEntryDirectory);
+    if (!entryFile) {
+        return null;
+    }
+    const sourceFile = state.program.getSourceFile(entryFile);
+    if (!sourceFile) {
+        return null;
+    }
+    const moduleSymbol = state.typeChecker.getSymbolAtLocation(sourceFile);
+    if (!moduleSymbol) {
+        return null;
+    }
+    const exports$1 = state.typeChecker.getExportsOfModule(moduleSymbol);
+    return new Set(exports$1.map((symbol) => symbol.getName()));
 }
-/**
- * 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');
@@ -253351,58 +253368,74 @@ function getEntryFileForNestedEntryPoint(rootEntryDirectory, relativeEntryDirect
     }
     return null;
 }
-/**
- * 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';
+function buildRewrittenImports({ baseImportPath, node, state, symbolToEntryPoint, }) {
     const groupedByTarget = new Map();
-    for (const [symbolName, relativeEntryPath] of symbolToEntryPoint.entries()) {
+    const remainingSpecifiers = [];
+    for (const specifier of node.specifiers) {
+        if (specifier.type !== dist$2.AST_NODE_TYPES.ImportSpecifier) {
+            remainingSpecifiers.push(specifier);
+            continue;
+        }
+        const importedName = getImportedName(specifier);
+        const relativeEntryPath = symbolToEntryPoint.get(importedName);
+        if (!relativeEntryPath) {
+            remainingSpecifiers.push(specifier);
+            continue;
+        }
         const targetSpecifier = `${baseImportPath}/${relativeEntryPath}`;
         if (!groupedByTarget.has(targetSpecifier)) {
             groupedByTarget.set(targetSpecifier, []);
         }
-        const targetGroup = groupedByTarget.get(targetSpecifier);
-        if (targetGroup) {
-            targetGroup.push(symbolName);
-        }
+        groupedByTarget.get(targetSpecifier)?.push(specifier);
     }
     const importStatements = [];
-    for (const [targetSpecifier, symbols] of groupedByTarget.entries()) {
-        const parts = symbols.map((symbolName) => {
-            const matchingSpecifier = node.specifiers.find((specifier) => specifier.type === dist$2.AST_NODE_TYPES.ImportSpecifier &&
-                (specifier.imported.type === dist$2.AST_NODE_TYPES.Identifier
-                    ? specifier.imported.name === symbolName
-                    : specifier.imported.value === symbolName));
-            if (!matchingSpecifier) {
-                return symbolName;
-            }
-            const importedName = matchingSpecifier.imported.type === dist$2.AST_NODE_TYPES.Identifier
-                ? matchingSpecifier.imported.name
-                : matchingSpecifier.imported.value;
-            const localName = matchingSpecifier.local.name;
-            return importedName === localName
-                ? importedName
-                : `${importedName} as ${localName}`;
-        });
-        const statement = `import ${isTypeOnlyImport ? 'type ' : ''}{${parts.join(', ')}} from '${targetSpecifier}';`;
-        importStatements.push(statement);
+    for (const [targetSpecifier, specifiers] of groupedByTarget.entries()) {
+        importStatements.push(buildNamedImportStatement({
+            importKind: node.importKind,
+            importPath: targetSpecifier,
+            specifiers,
+            state,
+        }));
+    }
+    const remainingImportStatement = buildImportStatement({
+        importKind: node.importKind,
+        importPath: baseImportPath,
+        specifiers: remainingSpecifiers,
+        state,
+    });
+    if (remainingImportStatement) {
+        importStatements.push(remainingImportStatement);
     }
     return importStatements.join('\n');
 }
+function buildNamedImportStatement({ importKind, importPath, specifiers, state, }) {
+    const importKeyword = importKind === 'type' ? 'import type' : 'import';
+    const parts = specifiers.map((specifier) => state.sourceCode.getText(specifier));
+    return `${importKeyword} {${parts.join(', ')}} from '${importPath}';`;
+}
+function buildImportStatement({ importKind, importPath, specifiers, state, }) {
+    if (specifiers.length === 0) {
+        return null;
+    }
+    const importKeyword = importKind === 'type' ? 'import type' : 'import';
+    const defaultSpecifier = specifiers.find((specifier) => specifier.type === dist$2.AST_NODE_TYPES.ImportDefaultSpecifier);
+    const namespaceSpecifier = specifiers.find((specifier) => specifier.type === dist$2.AST_NODE_TYPES.ImportNamespaceSpecifier);
+    const namedSpecifiers = specifiers.filter((specifier) => specifier.type === dist$2.AST_NODE_TYPES.ImportSpecifier);
+    const clauses = [];
+    if (defaultSpecifier) {
+        clauses.push(state.sourceCode.getText(defaultSpecifier));
+    }
+    if (namespaceSpecifier) {
+        clauses.push(state.sourceCode.getText(namespaceSpecifier));
+    }
+    if (namedSpecifiers.length > 0) {
+        clauses.push(`{${namedSpecifiers.map((specifier) => state.sourceCode.getText(specifier)).join(', ')}}`);
+    }
+    if (clauses.length === 0) {
+        return null;
+    }
+    return `${importKeyword} ${clauses.join(', ')} from '${importPath}';`;
+}
 
 function getTypeName(param) {
     const typeAnnotation = param?.parameter?.typeAnnotation ?? param?.typeAnnotation;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@taiga-ui/eslint-plugin-experience-next",
-  "version": "0.497.0",
+  "version": "0.498.0",
   "description": "An ESLint plugin to enforce a consistent code styles across taiga-ui projects",
   "repository": {
     "type": "git",
@@ -27,7 +27,7 @@
   ],
   "type": "module",
   "devDependencies": {
-    "@typescript-eslint/rule-tester": "^8.59.1"
+    "@typescript-eslint/rule-tester": "8.59.1"
   },
   "peerDependencies": {
     "@eslint/compat": "^2.0.5",