@taiga-ui/eslint-plugin-experience-next 0.411.0 → 0.413.0

package/README.md

@@ -48,6 +48,7 @@ export default [
 | no-deep-imports-to-indexed-packages | Disallow deep imports from packages that expose an index.ts next to ng-package.json or package.json | ✅  | 🔧  |     |
 | no-href-with-router-link            | Do not use href and routerLink attributes together on the same element                              |     | 🔧  |     |
 | no-implicit-public                  | Require explicit `public` modifier for class members and parameter properties                       | ✅  | 🔧  |     |
+| no-playwright-empty-fill            | Enforce `clear()` over `fill('')` in Playwright tests                                               | ✅  | 🔧  |     |
 | standalone-imports-sort             | Sort imports alphabetically                                                                         | ✅  | 🔧  |     |
 | prefer-deep-imports                 | Allow deep imports of Taiga UI packages                                                             |     | 🔧  |     |
 | short-tui-imports                   | Shorten TuiXxxComponent / TuiYyyDirective in Angular metadata                                       | ✅  | 🔧  |     |

package/index.d.ts

@@ -37,6 +37,9 @@ declare const plugin: {
         'no-implicit-public': import("@typescript-eslint/utils/ts-eslint").RuleModule<"implicitPublic", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
             name: string;
         };
+        'no-playwright-empty-fill': import("@typescript-eslint/utils/ts-eslint").RuleModule<"useClear", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+            name: string;
+        };
         'object-single-line': import("@typescript-eslint/utils/ts-eslint").RuleModule<"oneLine", [{
             printWidth: number;
         }], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {

package/index.esm.js

@@ -946,6 +946,7 @@ var recommended = defineConfig([
         files: ['**/*.pw.spec.ts'],
         extends: [playwright.configs['flat/recommended']],
         rules: {
+            '@taiga-ui/experience-next/no-playwright-empty-fill': 'error',
             'compat/compat': 'off',
             'jest/prefer-importing-jest-globals': 'off',
             'playwright/expect-expect': [
@@ -1242,8 +1243,8 @@ function intersect(a, b) {
     return a.some((type) => origin.has(type));
 }
 
-const createRule$a = ESLintUtils.RuleCreator((name) => name);
-var classPropertyNaming = createRule$a({
+const createRule$b = ESLintUtils.RuleCreator((name) => name);
+var classPropertyNaming = createRule$b({
     create(context, [configs]) {
         const parserServices = ESLintUtils.getParserServices(context);
         const typeChecker = parserServices.program.getTypeChecker();
@@ -1412,9 +1413,9 @@ function isExternalPureTuple(typeChecker, type) {
     return typeArgs.every((item) => isClassType(item));
 }
 
-const createRule$9 = ESLintUtils.RuleCreator((name) => name);
+const createRule$a = ESLintUtils.RuleCreator((name) => name);
 const MESSAGE_ID$5 = 'spreadArrays';
-var flatExports = createRule$9({
+var flatExports = createRule$a({
     create(context) {
         const parserServices = ESLintUtils.getParserServices(context);
         const typeChecker = parserServices.program.getTypeChecker();
@@ -1541,8 +1542,8 @@ var flatExports = createRule$9({
 
 const MESSAGE_ID$4 = 'invalid-injection-token-description';
 const ERROR_MESSAGE$3 = "InjectionToken's description should contain token's name";
-const createRule$8 = ESLintUtils.RuleCreator((name) => name);
-const rule$5 = createRule$8({
+const createRule$9 = ESLintUtils.RuleCreator((name) => name);
+const rule$6 = createRule$9({
     create(context) {
         return {
             'NewExpression[callee.name="InjectionToken"]'(node) {
@@ -1600,8 +1601,8 @@ const DEFAULT_OPTIONS = {
     importDeclaration: '^@taiga-ui*',
     projectName: String.raw `(?<=^@taiga-ui/)([-\w]+)`,
 };
-const createRule$7 = ESLintUtils.RuleCreator((name) => name);
-const rule$4 = createRule$7({
+const createRule$8 = ESLintUtils.RuleCreator((name) => name);
+const rule$5 = createRule$8({
     create(context) {
         const { currentProject, deepImport, ignoreImports, importDeclaration, projectName, } = { ...DEFAULT_OPTIONS, ...context.options[0] };
         const isDeepImport = (source) => !!source && new RegExp(deepImport, 'g').test(source);
@@ -1680,13 +1681,13 @@ const rule$4 = createRule$7({
     name: 'no-deep-imports',
 });
 
-const createRule$6 = ESLintUtils.RuleCreator((name) => name);
+const createRule$7 = 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({
+var noDeepImportsToIndexedPackages = createRule$7({
     create(context) {
         const parserServices = ESLintUtils.getParserServices(context);
         const program = parserServices.program;
@@ -1929,8 +1930,8 @@ const config = {
     },
 };
 
-const createRule$5 = ESLintUtils.RuleCreator((name) => name);
-const rule$3 = createRule$5({
+const createRule$6 = ESLintUtils.RuleCreator((name) => name);
+const rule$4 = createRule$6({
     create(context) {
         const checkImplicitPublic = (node) => {
             const classRef = getClass(node);
@@ -2002,6 +2003,95 @@ function getClass(node) {
     return getClass(node.parent);
 }
 
+const createRule$5 = ESLintUtils.RuleCreator((name) => name);
+const rule$3 = createRule$5({
+    create(context) {
+        const services = ESLintUtils.getParserServices(context);
+        const checker = services.program.getTypeChecker();
+        return {
+            CallExpression(node) {
+                const callee = node.callee;
+                if (callee.type !== AST_NODE_TYPES$1.MemberExpression) {
+                    return;
+                }
+                const property = callee.property;
+                if (property.type !== AST_NODE_TYPES$1.Identifier ||
+                    property.name !== 'fill' ||
+                    node.arguments.length !== 1) {
+                    return;
+                }
+                const [argument] = node.arguments;
+                if (!argument || !isEmptyString(argument)) {
+                    return;
+                }
+                const objectExpression = callee.object;
+                const tsNode = services.esTreeNodeToTSNodeMap.get(objectExpression);
+                const type = checker.getTypeAtLocation(tsNode);
+                if (!isPlaywrightLocator(type, checker)) {
+                    return;
+                }
+                context.report({
+                    fix(fixer) {
+                        const objectText = context.sourceCode.getText(objectExpression);
+                        return fixer.replaceText(node, `${objectText}.clear()`);
+                    },
+                    messageId: 'useClear',
+                    node,
+                });
+            },
+        };
+    },
+    defaultOptions: [],
+    meta: {
+        docs: {
+            description: "Enforce Playwright clear() instead of fill('') for emptying fields",
+        },
+        fixable: 'code',
+        messages: { useClear: "Use clear() instead of fill('') when emptying a field" },
+        schema: [],
+        type: 'suggestion',
+    },
+    name: 'no-playwright-empty-fill',
+});
+function isEmptyString(node) {
+    return ((node.type === AST_NODE_TYPES$1.Literal && node.value === '') ||
+        (node.type === AST_NODE_TYPES$1.TemplateLiteral &&
+            node.expressions.length === 0 &&
+            node.quasis.length === 1 &&
+            node.quasis[0]?.value.cooked === ''));
+}
+function isPlaywrightLocator(type, checker) {
+    if (isPlaywrightLocatorType(type)) {
+        return true;
+    }
+    const locatorProp = type.getProperty('locator');
+    if (!locatorProp) {
+        return false;
+    }
+    const decl = locatorProp.valueDeclaration ?? locatorProp.declarations?.[0];
+    if (!decl) {
+        return false;
+    }
+    const locatorType = checker.getTypeOfSymbolAtLocation(locatorProp, decl);
+    return isPlaywrightLocatorType(locatorType);
+}
+function isPlaywrightLocatorType(type) {
+    if (type.isUnionOrIntersection()) {
+        return type.types.some(isPlaywrightLocatorType);
+    }
+    const symbol = type.getSymbol() ?? type.aliasSymbol;
+    if (symbol?.getName() !== 'Locator') {
+        return false;
+    }
+    const declarations = symbol.getDeclarations() ?? [];
+    return declarations.some((decl) => {
+        const fileName = decl.getSourceFile().fileName.replaceAll('\\', '/');
+        return (fileName.includes('/node_modules/playwright/') ||
+            fileName.includes('/node_modules/@playwright/test/') ||
+            fileName.includes('/node_modules/playwright-core/'));
+    });
+}
+
 const createRule$4 = ESLintUtils.RuleCreator((name) => name);
 const rule$2 = createRule$4({
     create(context, [{ printWidth }]) {
@@ -3105,11 +3195,12 @@ const plugin = {
         'class-property-naming': classPropertyNaming,
         'decorator-key-sort': config$1,
         'flat-exports': flatExports,
-        'injection-token-description': rule$5,
-        'no-deep-imports': rule$4,
+        'injection-token-description': rule$6,
+        'no-deep-imports': rule$5,
         'no-deep-imports-to-indexed-packages': noDeepImportsToIndexedPackages,
         'no-href-with-router-link': config,
-        'no-implicit-public': rule$3,
+        'no-implicit-public': rule$4,
+        'no-playwright-empty-fill': rule$3,
         'object-single-line': rule$2,
         'prefer-deep-imports': preferDeepImports,
         'short-tui-imports': rule$1,

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@taiga-ui/eslint-plugin-experience-next",
-  "version": "0.411.0",
+  "version": "0.413.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.54.0",
-    "glob": "13.0.1"
+    "@typescript-eslint/rule-tester": "8.55.0",
+    "glob": "13.0.2"
   },
   "peerDependencies": {
     "@eslint/compat": "^2.0.2",
@@ -16,7 +16,7 @@
     "@smarttools/eslint-plugin-rxjs": "^1.0.22",
     "@stylistic/eslint-plugin": "^5.8.0",
     "@types/glob": "*",
-    "@typescript-eslint/eslint-plugin": "^8.54.0",
+    "@typescript-eslint/eslint-plugin": "^8.55.0",
     "angular-eslint": "^20.7.0",
     "eslint": "^9.39.2",
     "eslint-config-prettier": "^10.1.7",
@@ -33,12 +33,12 @@
     "eslint-plugin-promise": "^7.2.1",
     "eslint-plugin-regexp": "^3.0.0",
     "eslint-plugin-simple-import-sort": "^12.1.1",
-    "eslint-plugin-sonarjs": "^3.0.6",
+    "eslint-plugin-sonarjs": "^3.0.7",
     "eslint-plugin-unicorn": "^62.0.0",
     "eslint-plugin-unused-imports": "^4.4.1",
     "glob": "*",
     "globals": "^17.3.0",
-    "typescript-eslint": "^8.54.0"
+    "typescript-eslint": "^8.55.0"
   },
   "publishConfig": {
     "access": "public"

package/rules/no-playwright-empty-fill.d.ts

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