@taiga-ui/eslint-plugin-experience-next 0.464.0 → 0.465.0

package/index.d.ts

@@ -18,6 +18,7 @@ declare const plugin: {
         'flat-exports': import("@typescript-eslint/utils/ts-eslint").RuleModule<"spreadArrays", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
             name: string;
         };
+        'html-logical-properties': import("eslint").Rule.RuleModule;
         'injection-token-description': import("@typescript-eslint/utils/ts-eslint").RuleModule<"invalid-injection-token-description", readonly unknown[], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
             name: string;
         };
@@ -37,6 +38,9 @@ declare const plugin: {
         'no-implicit-public': import("@typescript-eslint/utils/ts-eslint").RuleModule<"implicitPublic", readonly unknown[], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
             name: string;
         };
+        'no-legacy-peer-deps': import("@typescript-eslint/utils/ts-eslint").RuleModule<"noLegacyPeerDeps", [], 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;
         };

package/index.esm.js

@@ -66,49 +66,6 @@ var htmlEslint = defineConfig([
                     message: 'Icons must be configured, for example: \n<button tuiIconButton [iconStart]="options.iconStart" [iconEnd]="options.iconEnd" /> \n<tui-icon [icon]="options.icon" />',
                 },
             ],
-            'html/no-restricted-attrs': [
-                'error',
-                {
-                    attrPatterns: [
-                        String.raw `\[style\.left(\.[a-z]+)?\]`,
-                        String.raw `\[style\.right(\.[a-z]+)?\]`,
-                        String.raw `\[style\.top(\.[a-z]+)?\]`,
-                        String.raw `\[style\.bottom(\.[a-z]+)?\]`,
-                        String.raw `\[style\.margin-left(\.[a-z]+)?\]`,
-                        String.raw `\[style\.margin-right(\.[a-z]+)?\]`,
-                        String.raw `\[style\.margin-top(\.[a-z]+)?\]`,
-                        String.raw `\[style\.margin-bottom(\.[a-z]+)?\]`,
-                        String.raw `\[style\.padding-left(\.[a-z]+)?\]`,
-                        String.raw `\[style\.padding-right(\.[a-z]+)?\]`,
-                        String.raw `\[style\.padding-top(\.[a-z]+)?\]`,
-                        String.raw `\[style\.padding-bottom(\.[a-z]+)?\]`,
-                        String.raw `\[style\.border-left(\.[a-z]+)?\]`,
-                        String.raw `\[style\.border-right(\.[a-z]+)?\]`,
-                        String.raw `\[style\.border-top(\.[a-z]+)?\]`,
-                        String.raw `\[style\.border-bottom(\.[a-z]+)?\]`,
-                    ],
-                    message: `
-Use logical CSS properties instead of directional properties. Replace:
-• left → inset-inline-start
-• right → inset-inline-end
-• top → inset-block-start
-• bottom → inset-block-end
-• margin-left → margin-inline-start
-• margin-right → margin-inline-end
-• margin-top → margin-block-start
-• margin-bottom → margin-block-end
-• padding-left → padding-inline-start
-• padding-right → padding-inline-end
-• padding-top → padding-block-start
-• padding-bottom → padding-block-end
-• border-left → border-inline-start
-• border-right → border-inline-end
-• border-top → border-block-start
-• border-bottom → border-block-end
-`,
-                    tagPatterns: ['.*'],
-                },
-            ],
             'html/require-closing-tags': 'off', // prettier conflicts
             'html/require-img-alt': ['error', { substitute: ['[alt]', '[attr.alt]'] }],
             'html/use-baseline': 'off',
@@ -213,6 +170,39 @@ const TUI_MEMBER_ORDERING_CONVENTION = [
     '#private-instance-method',
 ];
 
+function buildAST(text) {
+    const lines = text.split('\n');
+    const lastLine = lines[lines.length - 1] ?? '';
+    return {
+        body: [],
+        comments: [],
+        loc: {
+            end: { column: lastLine.length, line: lines.length },
+            start: { column: 0, line: 1 },
+        },
+        range: [0, text.length],
+        tokens: [],
+        type: 'Program',
+    };
+}
+function parse(text) {
+    return buildAST(text);
+}
+function parseForESLint(text) {
+    return {
+        ast: buildAST(text),
+        scopeManager: null,
+        services: {},
+        visitorKeys: { Program: [] },
+    };
+}
+
+var npmrcParser = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    parse: parse,
+    parseForESLint: parseForESLint
+});
+
 const require$2 = createRequire(import.meta.url);
 function getAngularVersion() {
     try {
@@ -989,6 +979,7 @@ var recommended = defineConfig([
             '@angular-eslint/template/prefer-control-flow': angularVersion >= modernAngularRules.preferControlFlow ? 'error' : 'off',
             '@angular-eslint/template/prefer-self-closing-tags': 'error',
             '@angular-eslint/template/prefer-template-literal': angularVersion >= modernAngularRules.templateLiteral ? 'error' : 'off',
+            '@taiga-ui/experience-next/html-logical-properties': 'error',
             '@taiga-ui/experience-next/no-href-with-router-link': 'error',
             '@taiga-ui/experience-next/no-project-as-in-ng-template': 'error',
         },
@@ -1162,6 +1153,11 @@ var recommended = defineConfig([
         files: ['**/*.md', '**/*.html', '**/*.cy.ts', '**/*.spec.ts'],
         rules: { 'no-irregular-whitespace': 'off' },
     },
+    {
+        files: ['**/.npmrc'],
+        languageOptions: { parser: npmrcParser },
+        rules: { '@taiga-ui/experience-next/no-legacy-peer-deps': 'error' },
+    },
 ]);
 
 const allPackageJSONs = globSync('**/package.json', {
@@ -1240,7 +1236,7 @@ function readJSON(path) {
     }
 }
 
-const config$3 = {
+const config$4 = {
     create(context) {
         const classesInFile = new Map();
         return {
@@ -1331,8 +1327,8 @@ function intersect(a, b) {
     return a.some((type) => origin.has(type));
 }
 
-const createRule$e = ESLintUtils.RuleCreator((name) => name);
-var classPropertyNaming = createRule$e({
+const createRule$f = ESLintUtils.RuleCreator((name) => name);
+var classPropertyNaming = createRule$f({
     create(context, [configs]) {
         const parserServices = ESLintUtils.getParserServices(context);
         const typeChecker = parserServices.program.getTypeChecker();
@@ -1399,7 +1395,7 @@ var classPropertyNaming = createRule$e({
     name: 'class-property-naming',
 });
 
-const config$2 = {
+const config$3 = {
     create(context) {
         const order = context.options[0] || {};
         return {
@@ -1501,9 +1497,9 @@ function isExternalPureTuple(typeChecker, type) {
     return typeArgs.every((item) => isClassType(item));
 }
 
-const createRule$d = ESLintUtils.RuleCreator((name) => name);
-const MESSAGE_ID$6 = 'spreadArrays';
-var flatExports = createRule$d({
+const createRule$e = ESLintUtils.RuleCreator((name) => name);
+const MESSAGE_ID$7 = 'spreadArrays';
+var flatExports = createRule$e({
     create(context) {
         const parserServices = ESLintUtils.getParserServices(context);
         const typeChecker = parserServices.program.getTypeChecker();
@@ -1568,7 +1564,7 @@ var flatExports = createRule$d({
                             fix(fixer) {
                                 return fixer.replaceText(elementNode, `...${meta.name}`);
                             },
-                            messageId: MESSAGE_ID$6,
+                            messageId: MESSAGE_ID$7,
                             node: elementNode,
                         });
                     }
@@ -1619,7 +1615,7 @@ var flatExports = createRule$d({
         },
         fixable: 'code',
         messages: {
-            [MESSAGE_ID$6]: 'Spread "{{ name }}" to avoid nested arrays in exported entities.',
+            [MESSAGE_ID$7]: 'Spread "{{ name }}" to avoid nested arrays in exported entities.',
         },
         schema: [],
         type: 'suggestion',
@@ -1627,10 +1623,90 @@ var flatExports = createRule$d({
     name: 'flat-exports',
 });
 
+const DIRECTIONAL_TO_LOGICAL = {
+    'border-bottom': 'border-block-end',
+    'border-left': 'border-inline-start',
+    'border-right': 'border-inline-end',
+    'border-top': 'border-block-start',
+    bottom: 'inset-block-end',
+    left: 'inset-inline-start',
+    'margin-bottom': 'margin-block-end',
+    'margin-left': 'margin-inline-start',
+    'margin-right': 'margin-inline-end',
+    'margin-top': 'margin-block-start',
+    'padding-bottom': 'padding-block-end',
+    'padding-left': 'padding-inline-start',
+    'padding-right': 'padding-inline-end',
+    'padding-top': 'padding-block-start',
+    right: 'inset-inline-end',
+    top: 'inset-block-start',
+};
+const STYLE_PREFIX = 'style.';
+const MESSAGE_ID$6 = 'html-logical-properties';
+const MESSAGE = `
+Use logical CSS properties instead of directional properties. Replace:
+• left → inset-inline-start
+• right → inset-inline-end
+• top → inset-block-start
+• bottom → inset-block-end
+• margin-left → margin-inline-start
+• margin-right → margin-inline-end
+• margin-top → margin-block-start
+• margin-bottom → margin-block-end
+• padding-left → padding-inline-start
+• padding-right → padding-inline-end
+• padding-top → padding-block-start
+• padding-bottom → padding-block-end
+• border-left → border-inline-start
+• border-right → border-inline-end
+• border-top → border-block-start
+• border-bottom → border-block-end
+`;
+const config$2 = {
+    create(context) {
+        return {
+            BoundAttribute(rawNode) {
+                const node = rawNode;
+                if (!node.keySpan.details?.startsWith(STYLE_PREFIX)) {
+                    return;
+                }
+                const logicalProperty = DIRECTIONAL_TO_LOGICAL[node.name];
+                if (!logicalProperty) {
+                    return;
+                }
+                const { keySpan } = node;
+                const propertyStart = keySpan.start.offset + STYLE_PREFIX.length;
+                const propertyEnd = propertyStart + node.name.length;
+                context.report({
+                    fix: (fixer) => fixer.replaceTextRange([propertyStart, propertyEnd], logicalProperty),
+                    loc: {
+                        end: {
+                            column: keySpan.end.col,
+                            line: keySpan.end.line + 1,
+                        },
+                        start: {
+                            column: keySpan.start.col,
+                            line: keySpan.start.line + 1,
+                        },
+                    },
+                    messageId: MESSAGE_ID$6,
+                });
+            },
+        };
+    },
+    meta: {
+        docs: { description: MESSAGE },
+        fixable: 'code',
+        messages: { [MESSAGE_ID$6]: MESSAGE },
+        schema: [],
+        type: 'suggestion',
+    },
+};
+
 const MESSAGE_ID$5 = 'invalid-injection-token-description';
 const ERROR_MESSAGE$3 = "InjectionToken's description should contain token's name";
-const createRule$c = ESLintUtils.RuleCreator((name) => name);
-const rule$9 = createRule$c({
+const createRule$d = ESLintUtils.RuleCreator((name) => name);
+const rule$a = createRule$d({
     create(context) {
         return {
             'NewExpression[callee.name="InjectionToken"]'(node) {
@@ -1697,8 +1773,8 @@ const DEFAULT_OPTIONS = {
     importDeclaration: '^@taiga-ui*',
     projectName: String.raw `(?<=^@taiga-ui/)([-\w]+)`,
 };
-const createRule$b = ESLintUtils.RuleCreator((name) => name);
-const rule$8 = createRule$b({
+const createRule$c = ESLintUtils.RuleCreator((name) => name);
+const rule$9 = createRule$c({
     create(context) {
         const { currentProject, deepImport, ignoreImports, importDeclaration, projectName, } = { ...DEFAULT_OPTIONS, ...context.options[0] };
         const hasNonCodeExtension = (source) => {
@@ -1785,13 +1861,13 @@ const rule$8 = createRule$b({
     name: 'no-deep-imports',
 });
 
-const createRule$a = ESLintUtils.RuleCreator((name) => name);
+const createRule$b = 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$a({
+var noDeepImportsToIndexedPackages = createRule$b({
     create(context) {
         const parserServices = ESLintUtils.getParserServices(context);
         const program = parserServices.program;
@@ -2031,8 +2107,8 @@ const config$1 = {
     },
 };
 
-const createRule$9 = ESLintUtils.RuleCreator((name) => name);
-const rule$7 = createRule$9({
+const createRule$a = ESLintUtils.RuleCreator((name) => name);
+const rule$8 = createRule$a({
     create(context) {
         const checkImplicitPublic = (node) => {
             const classRef = getClass(node);
@@ -2103,6 +2179,46 @@ function getClass(node) {
     return getClass(node.parent);
 }
 
+const createRule$9 = ESLintUtils.RuleCreator((name) => name);
+const LEGACY_PEER_DEPS_PATTERN = /^legacy-peer-deps\s*=\s*true$/i;
+const rule$7 = createRule$9({
+    create(context) {
+        return {
+            Program(node) {
+                const text = context.sourceCode.getText(node);
+                const lines = text.split('\n');
+                for (const [index, line] of lines.entries()) {
+                    const trimmed = line.trim();
+                    if (!trimmed || trimmed.startsWith('#') || trimmed.startsWith(';')) {
+                        continue;
+                    }
+                    if (LEGACY_PEER_DEPS_PATTERN.test(trimmed)) {
+                        const startColumn = line.search(/\S/);
+                        context.report({
+                            loc: {
+                                end: { column: line.length, line: index + 1 },
+                                start: { column: startColumn, line: index + 1 },
+                            },
+                            messageId: 'noLegacyPeerDeps',
+                        });
+                    }
+                }
+            },
+        };
+    },
+    meta: {
+        docs: {
+            description: 'Disallow legacy-peer-deps=true in .npmrc. Fix peer dependency conflicts instead of bypassing them.',
+        },
+        messages: {
+            noLegacyPeerDeps: 'Do not use "legacy-peer-deps=true" in .npmrc. Fix peer dependency conflicts instead of bypassing the resolver.',
+        },
+        schema: [],
+        type: 'problem',
+    },
+    name: 'no-legacy-peer-deps',
+});
+
 const createRule$8 = ESLintUtils.RuleCreator((name) => name);
 const rule$6 = createRule$8({
     create(context) {
@@ -3748,15 +3864,17 @@ const plugin = {
         version: pkg.version,
     },
     rules: {
-        'array-as-const': config$3,
+        'array-as-const': config$4,
         'class-property-naming': classPropertyNaming,
-        'decorator-key-sort': config$2,
+        'decorator-key-sort': config$3,
         'flat-exports': flatExports,
-        'injection-token-description': rule$9,
-        'no-deep-imports': rule$8,
+        'html-logical-properties': config$2,
+        'injection-token-description': rule$a,
+        'no-deep-imports': rule$9,
         'no-deep-imports-to-indexed-packages': noDeepImportsToIndexedPackages,
         'no-href-with-router-link': config$1,
-        'no-implicit-public': rule$7,
+        'no-implicit-public': rule$8,
+        'no-legacy-peer-deps': rule$7,
         'no-playwright-empty-fill': rule$6,
         'no-project-as-in-ng-template': config,
         'no-redundant-type-annotation': rule$5,

package/package.json

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

package/rules/html-logical-properties.d.ts

@@ -0,0 +1,3 @@
+import { type Rule } from 'eslint';
+declare const config: Rule.RuleModule;
+export default config;

package/rules/no-legacy-peer-deps.d.ts

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

package/rules/utils/npmrc-parser.d.ts

@@ -0,0 +1,25 @@
+interface NpmrcAST {
+    type: 'Program';
+    body: never[];
+    comments: never[];
+    tokens: never[];
+    range: [number, number];
+    loc: {
+        start: {
+            line: number;
+            column: number;
+        };
+        end: {
+            line: number;
+            column: number;
+        };
+    };
+}
+export declare function parse(text: string): NpmrcAST;
+export declare function parseForESLint(text: string): {
+    ast: NpmrcAST;
+    visitorKeys: Record<string, string[]>;
+    scopeManager: null;
+    services: Record<string, never>;
+};
+export {};