@taiga-ui/eslint-plugin-experience-next 0.382.0 → 0.384.0

package/index.d.ts

@@ -11,29 +11,49 @@ declare const plugin: {
     };
     rules: {
         'array-as-const': import("eslint").Rule.RuleModule;
-        'class-property-naming': import("@typescript-eslint/utils/ts-eslint").RuleModule<"invalidName", [import("./rules/class-property-naming").RuleConfig[]], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+        'class-property-naming': import("@typescript-eslint/utils/ts-eslint").RuleModule<"invalidName", [import("./rules/class-property-naming").RuleConfig[]], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+            name: string;
+        };
         'decorator-key-sort': import("eslint").Rule.RuleModule;
-        'flat-exports': import("@typescript-eslint/utils/ts-eslint").RuleModule<"spreadArrays", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
-        'injection-token-description': import("@typescript-eslint/utils/ts-eslint").RuleModule<"invalid-injection-token-description", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+        'flat-exports': import("@typescript-eslint/utils/ts-eslint").RuleModule<"spreadArrays", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+            name: string;
+        };
+        'injection-token-description': import("@typescript-eslint/utils/ts-eslint").RuleModule<"invalid-injection-token-description", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+            name: string;
+        };
         'no-deep-imports': import("@typescript-eslint/utils/ts-eslint").RuleModule<"no-deep-imports", [{
             currentProject: string;
             deepImport: string;
             ignoreImports: string[];
             importDeclaration: string;
             projectName: string;
-        }], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
-        'no-deep-imports-to-indexed-packages': import("@typescript-eslint/utils/ts-eslint").RuleModule<"deepImport", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+        }], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+            name: string;
+        };
+        'no-deep-imports-to-indexed-packages': import("@typescript-eslint/utils/ts-eslint").RuleModule<"deepImport", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+            name: string;
+        };
         'no-href-with-router-link': import("eslint").Rule.RuleModule;
-        'no-implicit-public': import("@typescript-eslint/utils/ts-eslint").RuleModule<"implicitPublic", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+        'no-implicit-public': import("@typescript-eslint/utils/ts-eslint").RuleModule<"implicitPublic", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+            name: string;
+        };
         'prefer-deep-imports': import("@typescript-eslint/utils/ts-eslint").RuleModule<"prefer-deep-imports", [{
             importFilter: string[] | string;
             strict?: boolean;
-        }], 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>;
+        }], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+            name: string;
+        };
+        '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> & {
+            name: string;
+        };
         'standalone-imports-sort': import("@typescript-eslint/utils/ts-eslint").RuleModule<"incorrectOrder", [{
             decorators?: string[];
-        }], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
-        'strict-tui-doc-example': import("@typescript-eslint/utils/ts-eslint").RuleModule<"strict-doc-example-extensions-invalid-key" | "strict-doc-example-extensions-invalid-value", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+        }], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+            name: string;
+        };
+        'strict-tui-doc-example': import("@typescript-eslint/utils/ts-eslint").RuleModule<"strict-doc-example-extensions-invalid-key" | "strict-doc-example-extensions-invalid-value", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+            name: string;
+        };
     };
 };
 export { TUI_RECOMMENDED_NAMING_CONVENTION } from './rules/convention';

package/index.esm.js

@@ -1435,7 +1435,7 @@ function isArray(node) {
 }
 
 function getConstArray(node) {
-    if (!node || node.type !== AST_NODE_TYPES$1.TSAsExpression) {
+    if (node?.type !== AST_NODE_TYPES$1.TSAsExpression) {
         return null;
     }
     const annotation = node.typeAnnotation;
@@ -1522,8 +1522,7 @@ var flatExports = createRule$8({
                             return;
                         }
                         const elementNode = arr.node.elements[index];
-                        if (!elementNode ||
-                            elementNode.type !== AST_NODE_TYPES.Identifier) {
+                        if (elementNode?.type !== AST_NODE_TYPES.Identifier) {
                             return;
                         }
                         const hasLocalArrayMeta = arrays.has(meta.name);
@@ -1556,7 +1555,7 @@ var flatExports = createRule$8({
                 const elements = [];
                 let isDirty = false;
                 for (const el of arrayExpression.elements) {
-                    if (!el || el.type !== AST_NODE_TYPES.Identifier) {
+                    if (el?.type !== AST_NODE_TYPES.Identifier) {
                         isDirty = true;
                         continue;
                     }
@@ -1750,54 +1749,154 @@ var noDeepImportsToIndexedPackages = createRule$5({
         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;
+        }
         return {
             ImportDeclaration(node) {
-                const importPath = node.source.value;
-                if (typeof importPath !== 'string' || importPath.startsWith('.')) {
+                const importSpecifier = node.source.value;
+                if (typeof importSpecifier !== 'string') {
                     return;
                 }
-                const containingFile = context.filename;
-                const { resolvedModule } = ts.resolveModuleName(importPath, containingFile, program.getCompilerOptions(), compilerHost);
-                const resolvedPath = resolvedModule?.resolvedFileName;
-                if (!resolvedPath || resolvedPath.endsWith('index.ts')) {
+                if (!isExternalModuleSpecifier(importSpecifier)) {
                     return;
                 }
-                const dir = path.dirname(resolvedPath);
-                const baseDir = path.resolve(dir, '..');
-                const indexPath = path.join(baseDir, 'index.ts');
-                const ngPackagePath = path.join(baseDir, 'ng-package.json');
-                const packageJsonPath = path.join(baseDir, 'package.json');
-                const hasIndex = fs.existsSync(indexPath);
-                const hasPackage = fs.existsSync(ngPackagePath) || fs.existsSync(packageJsonPath);
-                if (hasIndex && hasPackage) {
-                    const relative = path.relative(baseDir, resolvedPath);
-                    const shouldFix = !!(relative && !relative.startsWith('..'));
-                    if (shouldFix) {
-                        const parts = importPath.split('/');
-                        const suggestedImport = parts.slice(0, -1).join('/');
-                        context.report({
-                            data: { importPath, suggestedImport },
-                            messageId: 'deepImport',
-                            node: node.source,
-                        });
-                    }
+                const packageRootSpecifier = getPackageRootSpecifier(importSpecifier);
+                const importSubpath = getSubpath(importSpecifier, packageRootSpecifier);
+                if (!importSubpath) {
+                    return;
+                }
+                const resolvedRootModuleFilePath = resolveTypescriptModule(packageRootSpecifier);
+                if (!resolvedRootModuleFilePath) {
+                    return;
+                }
+                const packageMarkerFilePath = pickPackageMarkerFile(resolvedRootModuleFilePath);
+                if (!packageMarkerFilePath) {
+                    return;
+                }
+                const packageDirectory = path.dirname(packageMarkerFilePath);
+                const indexFilePath = pickIndexFileInDirectory(packageDirectory);
+                if (!indexFilePath) {
+                    return;
+                }
+                const hasMatchingReExport = indexExportsSubpath(indexFilePath, importSubpath);
+                if (!hasMatchingReExport) {
+                    return;
                 }
+                context.report({
+                    data: {
+                        importPath: importSpecifier,
+                        suggestedImport: packageRootSpecifier,
+                    },
+                    messageId: 'deepImport',
+                    node: node.source,
+                });
             },
         };
     },
     defaultOptions: [],
     meta: {
         docs: {
-            description: 'Disallow deep imports from packages that expose an index.ts next to ng-package.json or package.json',
+            description: 'Disallow deep imports only when package root index.ts (or index.d.ts) re-exports that subpath, and the package is marked by ng-package.json or package.json',
         },
         messages: {
-            deepImport: 'Import "{{importPath}}" should go through the package index.ts (use "{{suggestedImport}}").',
+            deepImport: 'Import "{{importPath}}" should go through the package root export (use "{{suggestedImport}}").',
         },
         schema: [],
         type: 'problem',
     },
     name: 'no-deep-imports-to-indexed-packages',
 });
+function isExternalModuleSpecifier(moduleSpecifier) {
+    if (!moduleSpecifier || moduleSpecifier.startsWith('.')) {
+        return false;
+    }
+    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('@');
+}
+function getPackageRootSpecifier(importSpecifier) {
+    const pathParts = importSpecifier.split('/');
+    if (isScopedPackage(importSpecifier)) {
+        if (pathParts.length >= 2) {
+            return `${pathParts[0]}/${pathParts[1]}`;
+        }
+        return importSpecifier;
+    }
+    return pathParts[0] ?? importSpecifier;
+}
+function getSubpath(importSpecifier, packageRootSpecifier) {
+    if (importSpecifier === packageRootSpecifier) {
+        return null;
+    }
+    if (!importSpecifier.startsWith(`${packageRootSpecifier}/`)) {
+        return null;
+    }
+    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';
@@ -1806,7 +1905,7 @@ const config = {
         return {
             Tag(node) {
                 const htmlNode = node;
-                if (!htmlNode?.name || htmlNode.name.toLowerCase() !== 'a') {
+                if (htmlNode?.name?.toLowerCase() !== 'a') {
                     return;
                 }
                 let hrefAttribute = null;
@@ -2311,7 +2410,7 @@ const rule$1 = createRule$2({
                     return;
                 }
                 const [arg] = expression.arguments;
-                const isNotObject = !arg || arg.type !== AST_NODE_TYPES.ObjectExpression;
+                const isNotObject = arg?.type !== AST_NODE_TYPES.ObjectExpression;
                 if (isNotObject) {
                     return;
                 }

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "@taiga-ui/eslint-plugin-experience-next",
-  "version": "0.382.0",
+  "version": "0.384.0",
   "description": "An ESLint plugin to enforce a consistent code styles across taiga-ui projects",
   "license": "Apache-2.0",
   "type": "module",
   "devDependencies": {
-    "@typescript-eslint/rule-tester": "8.50.0",
+    "@typescript-eslint/rule-tester": "8.53.0",
     "glob": "13.0.0"
   },
   "peerDependencies": {
@@ -16,7 +16,7 @@
     "@smarttools/eslint-plugin-rxjs": "^1.0.22",
     "@stylistic/eslint-plugin": "^5.6.1",
     "@types/glob": "*",
-    "@typescript-eslint/eslint-plugin": "^8.50.0",
+    "@typescript-eslint/eslint-plugin": "^8.53.0",
     "angular-eslint": "^20.7.0",
     "eslint": "^9.39.2",
     "eslint-config-prettier": "^10.1.7",
@@ -28,7 +28,7 @@
     "eslint-plugin-jest": "^29.5.0",
     "eslint-plugin-package-json": "^0.85.0",
     "eslint-plugin-perfectionist": "^4.15.1",
-    "eslint-plugin-playwright": "^2.4.0",
+    "eslint-plugin-playwright": "^2.5.0",
     "eslint-plugin-prettier": "^5.5.4",
     "eslint-plugin-promise": "^7.2.1",
     "eslint-plugin-simple-import-sort": "^12.1.1",

package/rules/class-property-naming.d.ts

@@ -4,5 +4,7 @@ export interface RuleConfig {
     newFieldName: string;
     withTypesSpecifier: string[];
 }
-declare const _default: ESLintUtils.RuleModule<"invalidName", [RuleConfig[]], unknown, ESLintUtils.RuleListener>;
+declare const _default: ESLintUtils.RuleModule<"invalidName", [RuleConfig[]], unknown, ESLintUtils.RuleListener> & {
+    name: string;
+};
 export default _default;

package/rules/flat-exports.d.ts

@@ -1,3 +1,5 @@
 import { ESLintUtils } from '@typescript-eslint/utils';
-declare const _default: ESLintUtils.RuleModule<"spreadArrays", [], unknown, ESLintUtils.RuleListener>;
+declare const _default: ESLintUtils.RuleModule<"spreadArrays", [], unknown, ESLintUtils.RuleListener> & {
+    name: string;
+};
 export default _default;

package/rules/injection-token-description.d.ts

@@ -1,3 +1,5 @@
 import { ESLintUtils } from '@typescript-eslint/utils';
-export declare const rule: ESLintUtils.RuleModule<"invalid-injection-token-description", [], unknown, ESLintUtils.RuleListener>;
+export declare const rule: ESLintUtils.RuleModule<"invalid-injection-token-description", [], unknown, ESLintUtils.RuleListener> & {
+    name: string;
+};
 export default rule;

package/rules/no-deep-imports-to-indexed-packages.d.ts

@@ -1,3 +1,5 @@
 import { ESLintUtils } from '@typescript-eslint/utils';
-declare const _default: ESLintUtils.RuleModule<"deepImport", [], unknown, ESLintUtils.RuleListener>;
+declare const _default: ESLintUtils.RuleModule<"deepImport", [], unknown, ESLintUtils.RuleListener> & {
+    name: string;
+};
 export default _default;

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

@@ -5,5 +5,7 @@ export declare const rule: ESLintUtils.RuleModule<"no-deep-imports", [{
     ignoreImports: string[];
     importDeclaration: string;
     projectName: string;
-}], unknown, ESLintUtils.RuleListener>;
+}], unknown, ESLintUtils.RuleListener> & {
+    name: string;
+};
 export default rule;

package/rules/no-implicit-public.d.ts

@@ -1,3 +1,5 @@
 import { ESLintUtils } from '@typescript-eslint/utils';
-export declare const rule: ESLintUtils.RuleModule<"implicitPublic", [], unknown, ESLintUtils.RuleListener>;
+export declare const rule: ESLintUtils.RuleModule<"implicitPublic", [], unknown, ESLintUtils.RuleListener> & {
+    name: string;
+};
 export default rule;

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

@@ -18,5 +18,7 @@ type RuleOptions = [
         strict?: boolean;
     }
 ];
-declare const _default: ESLintUtils.RuleModule<"prefer-deep-imports", RuleOptions, unknown, ESLintUtils.RuleListener>;
+declare const _default: ESLintUtils.RuleModule<"prefer-deep-imports", RuleOptions, unknown, ESLintUtils.RuleListener> & {
+    name: string;
+};
 export default _default;

package/rules/short-tui-imports.d.ts

@@ -11,5 +11,7 @@ export type Options = [
 ];
 export type MessageIds = 'replaceTuiImport';
 export declare const MESSAGE_ID: MessageIds;
-export declare const rule: ESLintUtils.RuleModule<"replaceTuiImport", Options, unknown, ESLintUtils.RuleListener>;
+export declare const rule: ESLintUtils.RuleModule<"replaceTuiImport", Options, unknown, ESLintUtils.RuleListener> & {
+    name: string;
+};
 export default rule;

package/rules/standalone-imports-sort.d.ts

@@ -2,5 +2,7 @@ import { ESLintUtils } from '@typescript-eslint/utils';
 type Options = [{
     decorators?: string[];
 }];
-declare const _default: ESLintUtils.RuleModule<"incorrectOrder", Options, unknown, ESLintUtils.RuleListener>;
+declare const _default: ESLintUtils.RuleModule<"incorrectOrder", Options, unknown, ESLintUtils.RuleListener> & {
+    name: string;
+};
 export default _default;

package/rules/strict-tui-doc-example.d.ts

@@ -2,5 +2,7 @@ import { ESLintUtils } from '@typescript-eslint/utils';
 declare const INVALID_KEY_MESSAGE_ID: "strict-doc-example-extensions-invalid-key";
 declare const INVALID_VALUE_MESSAGE_ID: "strict-doc-example-extensions-invalid-value";
 type MessageIds = typeof INVALID_KEY_MESSAGE_ID | typeof INVALID_VALUE_MESSAGE_ID;
-export declare const rule: ESLintUtils.RuleModule<MessageIds, [], unknown, ESLintUtils.RuleListener>;
+export declare const rule: ESLintUtils.RuleModule<MessageIds, [], unknown, ESLintUtils.RuleListener> & {
+    name: string;
+};
 export default rule;