@taiga-ui/eslint-plugin-experience-next 0.396.0 → 0.398.0

package/index.esm.js

@@ -1665,14 +1665,113 @@ const rule$4 = createRule$7({
 });
 
 const createRule$6 = ESLintUtils.RuleCreator((name) => name);
+const resolveCacheByOptions = new WeakMap();
+const nearestFileUpCache = new Map();
+const markerCache = new Map();
+const indexFileCache = new Map();
+const indexExportsCache = new Map();
 var noDeepImportsToIndexedPackages = createRule$6({
     create(context) {
         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;
+        const compilerOptions = program.getCompilerOptions();
+        const compilerHost = ts.createCompilerHost(compilerOptions, true);
+        const containingDir = path.dirname(context.filename);
+        function resolveTypescriptModuleCached(moduleSpecifier) {
+            let cache = resolveCacheByOptions.get(compilerOptions);
+            if (!cache) {
+                cache = new Map();
+                resolveCacheByOptions.set(compilerOptions, cache);
+            }
+            const key = `${containingDir}\0${moduleSpecifier}`;
+            if (cache.has(key)) {
+                return cache.get(key);
+            }
+            const resolved = ts.resolveModuleName(moduleSpecifier, context.filename, compilerOptions, compilerHost);
+            const file = resolved.resolvedModule?.resolvedFileName ?? null;
+            cache.set(key, file);
+            return file;
+        }
+        function findNearestFileUpwardsCached(startDirectory, fileName) {
+            const key = `${startDirectory}\0${fileName}`;
+            if (nearestFileUpCache.has(key)) {
+                return nearestFileUpCache.get(key);
+            }
+            let currentDirectory = startDirectory;
+            while (currentDirectory.length > 0) {
+                const candidatePath = path.join(currentDirectory, fileName);
+                if (fs.existsSync(candidatePath)) {
+                    nearestFileUpCache.set(key, candidatePath);
+                    return candidatePath;
+                }
+                const parentDirectory = path.dirname(currentDirectory);
+                if (parentDirectory === currentDirectory) {
+                    break;
+                }
+                currentDirectory = parentDirectory;
+            }
+            nearestFileUpCache.set(key, null);
+            return null;
+        }
+        function pickPackageMarkerFileCached(resolvedRootFilePath) {
+            if (markerCache.has(resolvedRootFilePath)) {
+                return markerCache.get(resolvedRootFilePath);
+            }
+            const resolvedRootDirectory = path.dirname(resolvedRootFilePath);
+            const nearestNgPackageJson = findNearestFileUpwardsCached(resolvedRootDirectory, 'ng-package.json');
+            const nearestPackageJson = findNearestFileUpwardsCached(resolvedRootDirectory, 'package.json');
+            const marker = nearestNgPackageJson ?? nearestPackageJson ?? null;
+            markerCache.set(resolvedRootFilePath, marker);
+            return marker;
+        }
+        function pickIndexFileInDirectoryCached(packageDirectory) {
+            if (indexFileCache.has(packageDirectory)) {
+                return indexFileCache.get(packageDirectory);
+            }
+            const indexTypescriptPath = path.join(packageDirectory, 'index.ts');
+            const indexTypesDeclarationPath = path.join(packageDirectory, 'index.d.ts');
+            let indexFilePath = null;
+            if (fs.existsSync(indexTypescriptPath)) {
+                indexFilePath = indexTypescriptPath;
+            }
+            else if (fs.existsSync(indexTypesDeclarationPath)) {
+                indexFilePath = indexTypesDeclarationPath;
+            }
+            indexFileCache.set(packageDirectory, indexFilePath);
+            return indexFilePath;
+        }
+        function getIndexReExportSpecifiersSet(indexFilePath) {
+            let stat;
+            try {
+                stat = fs.statSync(indexFilePath);
+            }
+            catch {
+                return new Set();
+            }
+            const cached = indexExportsCache.get(indexFilePath);
+            if (cached?.mtimeMs === stat.mtimeMs) {
+                return cached.set;
+            }
+            const fileText = fs.readFileSync(indexFilePath, 'utf8');
+            const sourceFile = ts.createSourceFile(indexFilePath, fileText, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
+            const set = new Set();
+            sourceFile.forEachChild((astNode) => {
+                if (!ts.isExportDeclaration(astNode)) {
+                    return;
+                }
+                const ms = astNode.moduleSpecifier;
+                if (ms && ts.isStringLiteral(ms)) {
+                    set.add(normalizeModuleSpecifier(stripKnownExtensions(ms.text)));
+                }
+            });
+            indexExportsCache.set(indexFilePath, { mtimeMs: stat.mtimeMs, set });
+            return set;
+        }
+        function indexExportsSubpathCached(indexFilePath, subpath) {
+            const set = getIndexReExportSpecifiersSet(indexFilePath);
+            const expectedSpecifier = normalizeModuleSpecifier(stripKnownExtensions(`./${subpath}`));
+            const expectedIndexSpecifier = normalizeModuleSpecifier(stripKnownExtensions(`./${subpath}/index`));
+            return set.has(expectedSpecifier) || set.has(expectedIndexSpecifier);
         }
         return {
             ImportDeclaration(node) {
@@ -1680,6 +1779,9 @@ var noDeepImportsToIndexedPackages = createRule$6({
                 if (typeof importSpecifier !== 'string') {
                     return;
                 }
+                if (!importSpecifier.includes('/')) {
+                    return;
+                }
                 if (!isExternalModuleSpecifier(importSpecifier)) {
                     return;
                 }
@@ -1688,20 +1790,20 @@ var noDeepImportsToIndexedPackages = createRule$6({
                 if (!importSubpath) {
                     return;
                 }
-                const resolvedRootModuleFilePath = resolveTypescriptModule(packageRootSpecifier);
+                const resolvedRootModuleFilePath = resolveTypescriptModuleCached(packageRootSpecifier);
                 if (!resolvedRootModuleFilePath) {
                     return;
                 }
-                const packageMarkerFilePath = pickPackageMarkerFile(resolvedRootModuleFilePath);
+                const packageMarkerFilePath = pickPackageMarkerFileCached(resolvedRootModuleFilePath);
                 if (!packageMarkerFilePath) {
                     return;
                 }
                 const packageDirectory = path.dirname(packageMarkerFilePath);
-                const indexFilePath = pickIndexFileInDirectory(packageDirectory);
+                const indexFilePath = pickIndexFileInDirectoryCached(packageDirectory);
                 if (!indexFilePath) {
                     return;
                 }
-                const hasMatchingReExport = indexExportsSubpath(indexFilePath, importSubpath);
+                const hasMatchingReExport = indexExportsSubpathCached(indexFilePath, importSubpath);
                 if (!hasMatchingReExport) {
                     return;
                 }
@@ -1735,23 +1837,6 @@ function isExternalModuleSpecifier(moduleSpecifier) {
     }
     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('@');
 }
@@ -1774,50 +1859,12 @@ function getSubpath(importSpecifier, packageRootSpecifier) {
     }
     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,6 +1,6 @@
 {
   "name": "@taiga-ui/eslint-plugin-experience-next",
-  "version": "0.396.0",
+  "version": "0.398.0",
   "description": "An ESLint plugin to enforce a consistent code styles across taiga-ui projects",
   "license": "Apache-2.0",
   "type": "module",
@@ -20,15 +20,15 @@
     "angular-eslint": "^20.7.0",
     "eslint": "^9.39.2",
     "eslint-config-prettier": "^10.1.7",
-    "eslint-plugin-compat": "^6.0.2",
+    "eslint-plugin-compat": "^6.1.0",
     "eslint-plugin-de-morgan": "^2.0.0",
     "eslint-plugin-decorator-position": "^6.0.0",
     "eslint-plugin-file-progress": "^3.0.2",
     "eslint-plugin-import": "^2.32.0",
     "eslint-plugin-jest": "^29.12.1",
-    "eslint-plugin-package-json": "^0.88.1",
+    "eslint-plugin-package-json": "^0.88.2",
     "eslint-plugin-perfectionist": "^5.4.0",
-    "eslint-plugin-playwright": "^2.5.0",
+    "eslint-plugin-playwright": "^2.5.1",
     "eslint-plugin-prettier": "^5.5.5",
     "eslint-plugin-promise": "^7.2.1",
     "eslint-plugin-simple-import-sort": "^12.1.1",