@taiga-ui/eslint-plugin-experience-next 0.501.0 → 0.502.0

package/index.esm.js

@@ -247667,8 +247667,8 @@ function getTypeAwareRuleContext(context) {
 
 const importGraphCacheByProgram = new WeakMap();
 const defaultExportCacheByProgram = new WeakMap();
+const fallbackResolutionByProgram = new WeakMap();
 const moduleExportNamesCache = new WeakMap();
-const resolutionStateByProgram = new WeakMap();
 const sourceFileCacheByProgram = new WeakMap();
 const codeFileExtensionRegExp = /\.[cm]?[jt]sx?$/;
 // Angular DI functions resolve tokens at instantiation time, not at module load time,
@@ -247689,8 +247689,38 @@ function createCanonicalFileName() {
             : resolvedFileName.toLowerCase();
     };
 }
-function getResolutionState(program) {
-    const cached = resolutionStateByProgram.get(program);
+function normalizeSlashes(fileName) {
+    return fileName.replaceAll('\\', '/');
+}
+function computeRelativeImportPath(fromFile, toFile) {
+    const relative = path.relative(path.dirname(fromFile), toFile);
+    const normalized = normalizeSlashes(relative).replace(codeFileExtensionRegExp, '');
+    return normalized.startsWith('.') ? normalized : `./${normalized}`;
+}
+function isProjectCodeFile(sourceFile) {
+    const normalizedFileName = normalizeSlashes(sourceFile.fileName);
+    return (!sourceFile.isDeclarationFile &&
+        codeFileExtensionRegExp.test(normalizedFileName) &&
+        !normalizedFileName.includes('/node_modules/'));
+}
+// Returns the module resolution cache that the TypeScript program itself populated during
+// compilation. Not part of the public ts.Program API but available at runtime on TS 4+.
+function getProgramResolutionCache(program) {
+    const record = program;
+    const getCache = record['getModuleResolutionCache'];
+    if (typeof getCache !== 'function') {
+        return null;
+    }
+    const cache = getCache.call(program);
+    if (cache === null ||
+        typeof cache !== 'object' ||
+        !('getOrCreateCacheForDirectory' in cache)) {
+        return null;
+    }
+    return cache;
+}
+function getFallbackResolution(program) {
+    const cached = fallbackResolutionByProgram.get(program);
     if (cached) {
         return cached;
     }
@@ -247699,23 +247729,22 @@ function getResolutionState(program) {
         compilerHost: ts.createCompilerHost(compilerOptions, true),
         resolutionCache: ts.createModuleResolutionCache(program.getCurrentDirectory(), (fileName) => fileName, compilerOptions),
     };
-    resolutionStateByProgram.set(program, state);
+    fallbackResolutionByProgram.set(program, state);
     return state;
 }
-function normalizeSlashes(fileName) {
-    return fileName.replaceAll('\\', '/');
-}
-function isProjectCodeFile(sourceFile) {
-    const normalizedFileName = normalizeSlashes(sourceFile.fileName);
-    return (!sourceFile.isDeclarationFile &&
-        codeFileExtensionRegExp.test(normalizedFileName) &&
-        !normalizedFileName.includes('/node_modules/'));
-}
 function resolveModule(program, containingFile, moduleSpecifier) {
-    const compilerOptions = program.getCompilerOptions();
-    const { compilerHost, resolutionCache } = getResolutionState(program);
-    const resolved = ts.resolveModuleName(moduleSpecifier, containingFile, compilerOptions, compilerHost, resolutionCache).resolvedModule ?? null;
-    return resolved;
+    // Prefer the program's own resolution cache (already populated during compilation)
+    // over running a fresh resolution, which requires file system access per unique
+    // (directory, module) pair and dominates lint time on cold starts.
+    const programCache = getProgramResolutionCache(program);
+    if (programCache) {
+        const fromCache = ts.resolveModuleNameFromCache(moduleSpecifier, containingFile, programCache);
+        if (fromCache !== undefined) {
+            return fromCache.resolvedModule ?? null;
+        }
+    }
+    const { compilerHost, resolutionCache } = getFallbackResolution(program);
+    return (ts.resolveModuleName(moduleSpecifier, containingFile, program.getCompilerOptions(), compilerHost, resolutionCache).resolvedModule ?? null);
 }
 function resolveModuleFileName(program, containingFile, moduleSpecifier) {
     const resolved = resolveModule(program, containingFile, moduleSpecifier);
@@ -247802,7 +247831,11 @@ function buildDependenciesByFileName(program, canonicalFileName) {
             if (!projectFileNames.has(targetFileName)) {
                 continue;
             }
-            edges.push({ moduleSpecifier, targetFileName });
+            edges.push({
+                isImport: ts.isImportDeclaration(statement),
+                moduleSpecifier,
+                targetFileName,
+            });
         }
         dependenciesByFileName.set(fileName, edges);
     }
@@ -247877,6 +247910,32 @@ function collectSelfCycles(dependenciesByFileName) {
     }
     return selfCycleFileNames;
 }
+function buildSccHasImportEdge(dependenciesByFileName, componentIdByFileName) {
+    const result = new Map();
+    for (const [fileName, edges] of dependenciesByFileName) {
+        const sourceComponentId = componentIdByFileName.get(fileName);
+        if (sourceComponentId === undefined || result.get(sourceComponentId) === true) {
+            continue;
+        }
+        for (const edge of edges) {
+            if (edge.isImport &&
+                componentIdByFileName.get(edge.targetFileName) === sourceComponentId) {
+                result.set(sourceComponentId, true);
+                break;
+            }
+        }
+    }
+    return result;
+}
+function buildBarrelFileNames(dependenciesByFileName) {
+    const result = new Set();
+    for (const [fileName, edges] of dependenciesByFileName) {
+        if (edges.some((edge) => !edge.isImport)) {
+            result.add(fileName);
+        }
+    }
+    return result;
+}
 function getImportGraph(program) {
     const cached = importGraphCacheByProgram.get(program);
     if (cached) {
@@ -247886,10 +247945,12 @@ function getImportGraph(program) {
     const { dependenciesByFileName, displayFileNameByFileName } = buildDependenciesByFileName(program, canonicalFileName);
     const { componentIdByFileName, componentSizeById } = findStronglyConnectedComponents(dependenciesByFileName);
     const cache = {
+        barrelFileNames: buildBarrelFileNames(dependenciesByFileName),
         componentIdByFileName,
         componentSizeById,
         dependenciesByFileName,
         displayFileNameByFileName,
+        sccHasImportEdgeById: buildSccHasImportEdge(dependenciesByFileName, componentIdByFileName),
         selfCycleFileNames: collectSelfCycles(dependenciesByFileName),
     };
     importGraphCacheByProgram.set(program, cache);
@@ -248103,6 +248164,34 @@ function getExportSpecifierName(name) {
 function hasNamedValueExport(exportNames, exportedName) {
     return exportedName !== 'default' && (exportNames?.has(exportedName) ?? false);
 }
+// Angular resolves the reference lazily (at instantiation, not at module load time)
+// in all of these contexts, so a cycle through them is safe at the ES module level.
+function isInAngularSafeContext(identifier) {
+    // TSESTree types parent as Node (non-optional), but the root node's parent is
+    // null at runtime. Widening to include null/undefined lets while(current) serve
+    // as the exit condition when traversal reaches the top of the tree.
+    let current = identifier.parent;
+    while (current) {
+        // Lazy evaluation: body runs only when the function/arrow is called.
+        if (current.type === dist$3.AST_NODE_TYPES.ArrowFunctionExpression ||
+            current.type === dist$3.AST_NODE_TYPES.FunctionExpression ||
+            current.type === dist$3.AST_NODE_TYPES.FunctionDeclaration) {
+            return true;
+        }
+        // Angular decorator metadata (@Component, @Directive, etc.) is processed
+        // after all modules in the cycle have finished loading.
+        if (current.type === dist$3.AST_NODE_TYPES.Decorator) {
+            return true;
+        }
+        // Non-static class field initializers run at instantiation time, not at
+        // module load time, so they do not create a load-time cycle edge.
+        if (current.type === dist$3.AST_NODE_TYPES.PropertyDefinition && !current.static) {
+            return true;
+        }
+        current = current.parent;
+    }
+    return false;
+}
 function isImportUsedOnlyAsAngularDiFirstArg(node, sourceCode) {
     const valueSpecifiers = node.specifiers.filter((specifier) => {
         if (specifier.type === dist$3.AST_NODE_TYPES.ImportDefaultSpecifier ||
@@ -248114,6 +248203,10 @@ function isImportUsedOnlyAsAngularDiFirstArg(node, sourceCode) {
     if (valueSpecifiers.length === 0) {
         return false;
     }
+    // True if at least one reference is a genuine DI call or lives in a lazy/decorator
+    // context. Pure type-only references don't count: an import used only as a type
+    // should use `import type` and is not considered safe from a cycle perspective.
+    let hasSafeRuntimeUsage = false;
     for (const specifier of valueSpecifiers) {
         const [variable] = sourceCode.getDeclaredVariables(specifier);
         if (!variable || variable.references.length === 0) {
@@ -248122,6 +248215,17 @@ function isImportUsedOnlyAsAngularDiFirstArg(node, sourceCode) {
         for (const ref of variable.references) {
             const { identifier } = ref;
             const parent = identifier.parent;
+            // Type-only references (e.g., param: Type<T>) don't create runtime
+            // dependencies. Skip without marking hasSafeRuntimeUsage — an import
+            // that is exclusively used as a type should use `import type` instead.
+            if (parent.type === dist$3.AST_NODE_TYPES.TSTypeReference) {
+                continue;
+            }
+            // References inside lazy/decorator contexts don't create load-time edges.
+            if (isInAngularSafeContext(identifier)) {
+                hasSafeRuntimeUsage = true;
+                continue;
+            }
             const callee = parent.type === dist$3.AST_NODE_TYPES.CallExpression ? parent.callee : null;
             const isDirectCall = callee?.type === dist$3.AST_NODE_TYPES.Identifier &&
                 ANGULAR_DI_FIRST_ARG_FUNCTIONS.has(callee.name);
@@ -248136,9 +248240,10 @@ function isImportUsedOnlyAsAngularDiFirstArg(node, sourceCode) {
                 parent.arguments[0] !== identifier) {
                 return false;
             }
+            hasSafeRuntimeUsage = true;
         }
     }
-    return true;
+    return hasSafeRuntimeUsage;
 }
 const rule$K = createRule({
     create(context) {
@@ -248165,18 +248270,111 @@ const rule$K = createRule({
             }
             const graph = getImportGraph(tsProgram);
             const targetFileName = findCyclicTargetFileName(graph, currentFileName, moduleSpecifier);
-            if (!targetFileName ||
-                (node.type === dist$3.AST_NODE_TYPES.ImportDeclaration &&
-                    isImportUsedOnlyAsAngularDiFirstArg(node, sourceCode))) {
+            if (!targetFileName) {
                 return;
             }
-            context.report({
-                data: {
-                    cyclePath: formatCyclePath(graph, currentFileName, targetFileName, context.cwd),
-                },
-                messageId: 'importCycle',
-                node: sourceNode,
-            });
+            const cyclePath = formatCyclePath(graph, currentFileName, targetFileName, context.cwd);
+            if (node.type === dist$3.AST_NODE_TYPES.ImportDeclaration) {
+                // Compute the redirect replacement eagerly so we can decide whether
+                // to suppress. If a redirect to the direct source file is possible,
+                // always report (the fix breaks the cycle). Otherwise, suppress when
+                // all usages are Angular-DI-safe (inject, class fields, etc.).
+                const replacement = computeCycleBreakingReplacement(node);
+                if (!replacement &&
+                    isImportUsedOnlyAsAngularDiFirstArg(node, sourceCode)) {
+                    return;
+                }
+                context.report({
+                    data: { cyclePath },
+                    fix: replacement
+                        ? (fixer) => [fixer.replaceText(node, replacement)]
+                        : undefined,
+                    messageId: 'importCycle',
+                    node: sourceNode,
+                });
+            }
+            else {
+                // For re-export nodes (export * from / export {x} from), suppress the
+                // error when the same SCC already contains an ImportDeclaration edge.
+                // That ImportDeclaration will be reported (and fixed) directly, so
+                // reporting the barrel re-export would create duplicate, unfixable noise.
+                const componentId = graph.componentIdByFileName.get(currentFileName);
+                if (componentId !== undefined &&
+                    graph.sccHasImportEdgeById.get(componentId) === true) {
+                    return;
+                }
+                context.report({
+                    data: { cyclePath },
+                    messageId: 'importCycle',
+                    node: sourceNode,
+                });
+            }
+        }
+        function computeCycleBreakingReplacement(node) {
+            // Only named imports can be safely redirected to their source file
+            if (node.specifiers.some((s) => s.type !== dist$3.AST_NODE_TYPES.ImportSpecifier)) {
+                return null;
+            }
+            const barrelFileName = resolveModuleFileName(tsProgram, context.filename, node.source.value);
+            const canonicalBarrelFileName = barrelFileName
+                ? canonicalFileName(barrelFileName)
+                : null;
+            // Not a barrel (has no re-export edges) — symbols are defined locally,
+            // so there is no shorter direct-source path to redirect to.
+            if (!canonicalBarrelFileName ||
+                !getImportGraph(tsProgram).barrelFileNames.has(canonicalBarrelFileName)) {
+                return null;
+            }
+            const specifiersBySourceFile = new Map();
+            for (const specifier of node.specifiers) {
+                if (specifier.type !== dist$3.AST_NODE_TYPES.ImportSpecifier) {
+                    return null;
+                }
+                const tsSpecifier = esTreeNodeToTSNodeMap.get(specifier);
+                if (!ts.isImportSpecifier(tsSpecifier)) {
+                    return null;
+                }
+                const localSymbol = checker.getSymbolAtLocation(tsSpecifier.name);
+                if (!localSymbol) {
+                    return null;
+                }
+                const originalSymbol = getAliasedSymbolIfNeeded(checker, localSymbol);
+                const { declarations } = originalSymbol;
+                const firstDeclaration = declarations?.[0];
+                if (!firstDeclaration) {
+                    return null;
+                }
+                const sourceFile = firstDeclaration.getSourceFile();
+                if (!isProjectCodeFile(sourceFile)) {
+                    return null;
+                }
+                const sourceFilePath = sourceFile.fileName;
+                // Symbol is defined directly in the barrel — no shorter path exists
+                if (canonicalBarrelFileName === canonicalFileName(sourceFilePath)) {
+                    return null;
+                }
+                const importedName = tsSpecifier.propertyName?.text ?? tsSpecifier.name.text;
+                const localName = tsSpecifier.name.text;
+                const typePrefix = specifier.importKind === 'type' ? 'type ' : '';
+                const specText = importedName === localName
+                    ? `${typePrefix}${importedName}`
+                    : `${typePrefix}${importedName} as ${localName}`;
+                const group = specifiersBySourceFile.get(sourceFilePath) ?? [];
+                group.push(specText);
+                specifiersBySourceFile.set(sourceFilePath, group);
+            }
+            if (specifiersBySourceFile.size === 0) {
+                return null;
+            }
+            const semi = sourceCode.getText(node).endsWith(';') ? ';' : '';
+            const quote = node.source.raw[0] ?? "'";
+            const importPrefix = node.importKind === 'type' ? 'import type' : 'import';
+            const newImports = [];
+            for (const [sourceFilePath, names] of specifiersBySourceFile) {
+                const relPath = computeRelativeImportPath(context.filename, sourceFilePath);
+                newImports.push(`${importPrefix} {${names.join(', ')}} from ${quote}${relPath}${quote}${semi}`);
+            }
+            return newImports.join('\n');
         }
         function checkDefaultImport(node) {
             if ((!checkDefaultImports && !checkNamedAsDefault) ||
@@ -250700,6 +250898,19 @@ function isNullableCallType(call, checker, nodeMap) {
         return false;
     }
 }
+function getTargetNode(call) {
+    const { parent } = call;
+    if (parent.type === dist$3.AST_NODE_TYPES.TSAsExpression) {
+        return parent;
+    }
+    if (parent.type === dist$3.AST_NODE_TYPES.UnaryExpression &&
+        parent.operator === '!' &&
+        parent.parent.type === dist$3.AST_NODE_TYPES.UnaryExpression &&
+        parent.parent.operator === '!') {
+        return parent.parent;
+    }
+    return call;
+}
 function getCalleeName(node) {
     const { callee } = node;
     if (callee.type === dist$3.AST_NODE_TYPES.MemberExpression &&
@@ -250795,11 +251006,7 @@ const rule$r = createRule({
                                 fixer.insertTextBefore(parentStatement, `const ${varName} = ${callText};\n\n${indent}`),
                             ];
                             for (const call of calls) {
-                                const { parent } = call;
-                                const target = parent.type === dist$3.AST_NODE_TYPES.TSAsExpression
-                                    ? parent
-                                    : call;
-                                fixes.push(fixer.replaceText(target, varName));
+                                fixes.push(fixer.replaceText(getTargetNode(call), varName));
                             }
                             return fixes;
                         }
@@ -250812,12 +251019,7 @@ const rule$r = createRule({
                         const bodyText = sourceCode.getText(arrowBody);
                         const bodyStart = arrowBody.range[0];
                         const targets = calls
-                            .map((call) => {
-                            const { parent } = call;
-                            return parent.type === dist$3.AST_NODE_TYPES.TSAsExpression
-                                ? parent
-                                : call;
-                        })
+                            .map(getTargetNode)
                             .sort((a, b) => a.range[0] - b.range[0]);
                         let replacedBody = '';
                         let lastIndex = 0;
@@ -250829,7 +251031,13 @@ const rule$r = createRule({
                         }
                         replacedBody += bodyText.slice(lastIndex);
                         const newBody = `{\n${innerIndent}const ${varName} = ${callText};\n\n${innerIndent}return ${replacedBody};\n${outerIndent}}`;
-                        return [fixer.replaceText(arrowBody, newBody)];
+                        const bodyRangeStart = arrowBody.range[0];
+                        const textBeforeBody = sourceCode.text.slice(0, bodyRangeStart);
+                        const whitespaceBeforeBody = /\s*$/.exec(textBeforeBody)?.[0] ?? '';
+                        const replaceFrom = bodyRangeStart - whitespaceBeforeBody.length;
+                        return [
+                            fixer.replaceTextRange([replaceFrom, arrowBody.range[1]], ` ${newBody}`),
+                        ];
                     },
                     messageId: 'noRepeatedSignalInConditional',
                     node: firstCall,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@taiga-ui/eslint-plugin-experience-next",
-  "version": "0.501.0",
+  "version": "0.502.0",
   "description": "An ESLint plugin to enforce a consistent code styles across taiga-ui projects",
   "repository": {
     "type": "git",