@taiga-ui/eslint-plugin-experience-next 0.392.0 → 0.394.0

package/index.d.ts

@@ -37,6 +37,11 @@ declare const plugin: {
         'no-implicit-public': import("@typescript-eslint/utils/ts-eslint").RuleModule<"implicitPublic", [], 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> & {
+            name: string;
+        };
         'prefer-deep-imports': import("@typescript-eslint/utils/ts-eslint").RuleModule<"prefer-deep-imports", [{
             importFilter: string[] | string;
             strict?: boolean;

package/index.esm.js

@@ -42,9 +42,7 @@ var htmlEslint = defineConfig([
         plugins: { html },
         extends: ['html/recommended'],
         language: 'html/html',
-        languageOptions: {
-            parser: htmlParser,
-        },
+        languageOptions: { parser: htmlParser },
         rules: {
             '@taiga-ui/experience-next/no-href-with-router-link': 'error',
             'html/indent': 'off', // prettier conflicts
@@ -100,20 +98,13 @@ var htmlEslint = defineConfig([
                 },
             ],
             'html/require-closing-tags': 'off', // prettier conflicts
-            'html/require-img-alt': [
-                'error',
-                {
-                    substitute: ['[alt]', '[attr.alt]'],
-                },
-            ],
+            'html/require-img-alt': ['error', { substitute: ['[alt]', '[attr.alt]'] }],
             'html/use-baseline': 'off',
         },
     },
     {
         files: ['**/demo/**/*.html'],
-        rules: {
-            'html/no-restricted-attr-values': 'off',
-        },
+        rules: { 'html/no-restricted-attr-values': 'off' },
     },
 ]);
 
@@ -204,9 +195,7 @@ const tsconfig = projectJsonExist('tsconfig.eslint.json') ||
     projectJsonExist('tsconfig.json') ||
     projectJsonExist('tsconfig.base.json');
 const parserOptions = tsconfig
-    ? {
-        project: [tsconfig],
-    }
+    ? { project: [tsconfig] }
     : {
         EXPERIMENTAL_useProjectService: {
             maximumDefaultProjectFileMatchCount_THIS_WILL_SLOW_DOWN_LINTING: Infinity,
@@ -314,13 +303,7 @@ var recommended = defineConfig([
                 { blankLine: 'any', next: '*', prev: ['case', 'default'] },
                 { blankLine: 'any', next: 'directive', prev: 'directive' },
             ],
-            '@stylistic/quotes': [
-                'error',
-                'single',
-                {
-                    avoidEscape: true,
-                },
-            ],
+            '@stylistic/quotes': ['error', 'single', { avoidEscape: true }],
             '@stylistic/type-annotation-spacing': 'error',
             '@typescript-eslint/adjacent-overload-signatures': 'off',
             '@typescript-eslint/array-type': [
@@ -510,9 +493,7 @@ var recommended = defineConfig([
             '@typescript-eslint/only-throw-error': 'error',
             '@typescript-eslint/parameter-properties': [
                 'error',
-                {
-                    allow: ['public readonly', 'protected readonly', 'private readonly'],
-                },
+                { allow: ['public readonly', 'protected readonly', 'private readonly'] },
             ],
             '@typescript-eslint/prefer-as-const': 'error',
             '@typescript-eslint/prefer-destructuring': 'off',
@@ -568,20 +549,8 @@ var recommended = defineConfig([
                     properties: 'above',
                 },
             ],
-            eqeqeq: [
-                'error',
-                'always',
-                {
-                    null: 'ignore',
-                },
-            ],
-            'func-style': [
-                'error',
-                'declaration',
-                {
-                    allowArrowFunctions: true,
-                },
-            ],
+            eqeqeq: ['error', 'always', { null: 'ignore' }],
+            'func-style': ['error', 'declaration', { allowArrowFunctions: true }],
             'guard-for-in': 'error',
             'import/consistent-type-specifier-style': ['error', 'prefer-inline'],
             'import/enforce-node-protocol-usage': ['error', 'always'],
@@ -594,12 +563,7 @@ var recommended = defineConfig([
             'import/no-mutable-exports': 'error',
             'import/no-self-import': 'error',
             'import/no-unresolved': 'off',
-            'import/no-useless-path-segments': [
-                'error',
-                {
-                    noUselessIndex: true,
-                },
-            ],
+            'import/no-useless-path-segments': ['error', { noUselessIndex: true }],
             'import/no-webpack-loader-syntax': 'error',
             'lines-around-comment': [
                 'error',
@@ -624,12 +588,7 @@ var recommended = defineConfig([
             'max-params': ['error', 5],
             'no-bitwise': 'error',
             'no-case-declarations': 'error',
-            'no-console': [
-                'error',
-                {
-                    allow: ['info', 'assert', 'warn', 'error'],
-                },
-            ],
+            'no-console': ['error', { allow: ['info', 'assert', 'warn', 'error'] }],
             'no-constant-condition': 'error',
             'no-empty': ['error', { allowEmptyCatch: true }],
             'no-extra-boolean-cast': 'error',
@@ -761,12 +720,7 @@ var recommended = defineConfig([
                 },
             ],
             'prefer-template': 'error',
-            'prettier/prettier': [
-                'error',
-                {
-                    endOfLine: 'auto',
-                },
-            ],
+            'prettier/prettier': ['error', { endOfLine: 'auto' }],
             'promise/always-return': 'off',
             'promise/catch-or-return': 'off',
             'promise/no-callback-in-promise': 'off',
@@ -776,21 +730,10 @@ var recommended = defineConfig([
             'simple-import-sort/imports': 'error',
             'sonarjs/no-identical-functions': 'error',
             'sonarjs/no-inverted-boolean-check': 'error',
-            'spaced-comment': [
-                'error',
-                'always',
-                {
-                    markers: ['/'],
-                },
-            ],
+            'spaced-comment': ['error', 'always', { markers: ['/'] }],
             'unicorn/consistent-empty-array-spread': 'error',
             'unicorn/escape-case': 'error',
-            'unicorn/filename-case': [
-                'error',
-                {
-                    case: 'kebabCase',
-                },
-            ],
+            'unicorn/filename-case': ['error', { case: 'kebabCase' }],
             'unicorn/new-for-builtins': 'error',
             'unicorn/no-array-method-this-argument': 'error',
             'unicorn/no-array-push-push': 'error',
@@ -816,9 +759,7 @@ var recommended = defineConfig([
     },
     {
         files: ['**/*.{ts,tsx}'],
-        plugins: {
-            rxjs,
-        },
+        plugins: { rxjs },
         extends: [angular.configs.tsRecommended],
         processor: angular.processInlineTemplates,
         rules: {
@@ -913,12 +854,11 @@ var recommended = defineConfig([
             ],
             '@taiga-ui/experience-next/no-deep-imports-to-indexed-packages': 'error',
             '@taiga-ui/experience-next/no-implicit-public': 'error',
+            '@taiga-ui/experience-next/object-single-line': ['error', { printWidth: 90 }],
             '@taiga-ui/experience-next/short-tui-imports': 'error',
             '@taiga-ui/experience-next/standalone-imports-sort': [
                 'error',
-                {
-                    decorators: ['Component', 'Directive', 'NgModule', 'Pipe'],
-                },
+                { decorators: ['Component', 'Directive', 'NgModule', 'Pipe'] },
             ],
             'rxjs/no-compat': 'error',
             'rxjs/no-connectable': 'error',
@@ -994,9 +934,7 @@ var recommended = defineConfig([
             'jest/prefer-importing-jest-globals': 'off',
             'playwright/expect-expect': [
                 'error',
-                {
-                    assertFunctionNames: ['expect', 'expect.soft'],
-                },
+                { assertFunctionNames: ['expect', 'expect.soft'] },
             ],
             'playwright/no-force-option': 'error',
             'playwright/no-networkidle': 'off',
@@ -1064,9 +1002,7 @@ var recommended = defineConfig([
             'jest/require-to-throw-message': 'off',
             'jest/require-top-level-describe': [
                 'error',
-                {
-                    maxNumberOfTopLevelDescribes: 1,
-                },
+                { maxNumberOfTopLevelDescribes: 1 },
             ],
             'jest/unbound-method': 'off',
             'jest/valid-title': 'error',
@@ -1102,20 +1038,14 @@ var recommended = defineConfig([
     },
     {
         files: ['**/*.md'],
-        plugins: {
-            markdown,
-        },
+        plugins: { markdown },
         extends: [markdown.configs.recommended],
         language: 'markdown/gfm',
-        rules: {
-            'markdown/require-alt-text': 'off',
-        },
+        rules: { 'markdown/require-alt-text': 'off' },
     },
     {
         files: ['**/*.md', '**/*.html', '**/*.cy.ts', '**/*.spec.ts'],
-        rules: {
-            'no-irregular-whitespace': 'off',
-        },
+        rules: { 'no-irregular-whitespace': 'off' },
     },
 ]);
 function projectJsonExist(filename) {
@@ -1248,9 +1178,7 @@ const config$2 = {
         };
     },
     meta: {
-        docs: {
-            description: 'Exported arrays of class references should use `as const`.',
-        },
+        docs: { description: 'Exported arrays of class references should use `as const`.' },
         fixable: 'code',
         messages: {
             shouldUseAsConst: 'Exported array of class references should be marked with `as const`.',
@@ -1298,8 +1226,8 @@ function intersect(a, b) {
     return a.some((type) => origin.has(type));
 }
 
-const createRule$9 = ESLintUtils.RuleCreator((name) => name);
-var classPropertyNaming = createRule$9({
+const createRule$a = ESLintUtils.RuleCreator((name) => name);
+var classPropertyNaming = createRule$a({
     create(context, [configs]) {
         const parserServices = ESLintUtils.getParserServices(context);
         const typeChecker = parserServices.program.getTypeChecker();
@@ -1468,9 +1396,9 @@ function isExternalPureTuple(typeChecker, type) {
     return typeArgs.every((item) => isClassType(item));
 }
 
-const createRule$8 = ESLintUtils.RuleCreator((name) => name);
+const createRule$9 = ESLintUtils.RuleCreator((name) => name);
 const MESSAGE_ID$5 = 'spreadArrays';
-var flatExports = createRule$8({
+var flatExports = createRule$9({
     create(context) {
         const parserServices = ESLintUtils.getParserServices(context);
         const typeChecker = parserServices.program.getTypeChecker();
@@ -1597,8 +1525,8 @@ var flatExports = createRule$8({
 
 const MESSAGE_ID$4 = 'invalid-injection-token-description';
 const ERROR_MESSAGE$3 = "InjectionToken's description should contain token's name";
-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) {
         return {
             'NewExpression[callee.name="InjectionToken"]'(node) {
@@ -1638,13 +1566,9 @@ const rule$4 = createRule$7({
     },
     defaultOptions: [],
     meta: {
-        docs: {
-            description: ERROR_MESSAGE$3,
-        },
+        docs: { description: ERROR_MESSAGE$3 },
         fixable: 'code',
-        messages: {
-            [MESSAGE_ID$4]: ERROR_MESSAGE$3,
-        },
+        messages: { [MESSAGE_ID$4]: ERROR_MESSAGE$3 },
         schema: [],
         type: 'problem',
     },
@@ -1660,8 +1584,8 @@ const DEFAULT_OPTIONS = {
     importDeclaration: '^@taiga-ui*',
     projectName: String.raw `(?<=^@taiga-ui/)([-\w]+)`,
 };
-const createRule$6 = ESLintUtils.RuleCreator((name) => name);
-const rule$3 = createRule$6({
+const createRule$7 = ESLintUtils.RuleCreator((name) => name);
+const rule$4 = createRule$7({
     create(context) {
         const { currentProject, deepImport, ignoreImports, importDeclaration, projectName, } = { ...DEFAULT_OPTIONS, ...context.options[0] };
         const isDeepImport = (source) => !!source && new RegExp(deepImport, 'g').test(source);
@@ -1703,13 +1627,9 @@ const rule$3 = createRule$6({
     },
     defaultOptions: [DEFAULT_OPTIONS],
     meta: {
-        docs: {
-            description: ERROR_MESSAGE$2,
-        },
+        docs: { description: ERROR_MESSAGE$2 },
         fixable: 'code',
-        messages: {
-            [MESSAGE_ID$3]: ERROR_MESSAGE$2,
-        },
+        messages: { [MESSAGE_ID$3]: ERROR_MESSAGE$2 },
         schema: [
             {
                 additionalProperties: false,
@@ -1744,8 +1664,8 @@ const rule$3 = createRule$6({
     name: 'no-deep-imports',
 });
 
-const createRule$5 = ESLintUtils.RuleCreator((name) => name);
-var noDeepImportsToIndexedPackages = createRule$5({
+const createRule$6 = ESLintUtils.RuleCreator((name) => name);
+var noDeepImportsToIndexedPackages = createRule$6({
     create(context) {
         const parserServices = ESLintUtils.getParserServices(context);
         const program = parserServices.program;
@@ -1939,19 +1859,15 @@ const config = {
         };
     },
     meta: {
-        docs: {
-            description: ERROR_MESSAGE$1,
-        },
+        docs: { description: ERROR_MESSAGE$1 },
         fixable: 'code',
-        messages: {
-            [MESSAGE_ID$2]: ERROR_MESSAGE$1,
-        },
+        messages: { [MESSAGE_ID$2]: ERROR_MESSAGE$1 },
         type: 'problem',
     },
 };
 
-const createRule$4 = ESLintUtils.RuleCreator((name) => name);
-const rule$2 = createRule$4({
+const createRule$5 = ESLintUtils.RuleCreator((name) => name);
+const rule$3 = createRule$5({
     create(context) {
         const checkImplicitPublic = (node) => {
             const classRef = getClass(node);
@@ -2007,9 +1923,7 @@ const rule$2 = createRule$4({
             description: 'Require explicit `public` modifier for class members and parameter properties',
         },
         fixable: 'code',
-        messages: {
-            implicitPublic: '{{kind}} {{name}} should be marked as public',
-        },
+        messages: { implicitPublic: '{{kind}} {{name}} should be marked as public' },
         schema: [],
         type: 'problem',
     },
@@ -2025,6 +1939,285 @@ function getClass(node) {
     return getClass(node.parent);
 }
 
+const createRule$4 = ESLintUtils.RuleCreator((name) => name);
+const rule$2 = createRule$4({
+    create(context, [{ printWidth }]) {
+        const sourceCode = context.sourceCode;
+        const getLineEndIndex = (lineStartIndex) => {
+            const text = sourceCode.text;
+            const newLineIndex = text.indexOf('\n', lineStartIndex);
+            const rawEndIndex = newLineIndex === -1 ? text.length : newLineIndex;
+            if (rawEndIndex > lineStartIndex && text[rawEndIndex - 1] === '\r') {
+                return rawEndIndex - 1;
+            }
+            return rawEndIndex;
+        };
+        const hasAnyCommentsInside = (node) => sourceCode.getCommentsInside(node).length > 0;
+        const isTemplateLikeExpression = (expression) => expression.type === AST_NODE_TYPES$1.TemplateLiteral ||
+            expression.type === AST_NODE_TYPES$1.TaggedTemplateExpression;
+        const isForbiddenProperty = (property) => {
+            if (property.type !== AST_NODE_TYPES$1.Property) {
+                return false;
+            }
+            if (property.kind === 'get' || property.kind === 'set' || property.method) {
+                return true;
+            }
+            const value = property.value;
+            if (value && typeof value === 'object' && 'type' in value) {
+                const expression = value;
+                if (isTemplateLikeExpression(expression)) {
+                    return true;
+                }
+            }
+            return false;
+        };
+        const canInlineObjectExpression = (node) => {
+            if (!node?.loc ||
+                node.properties.length !== 1 ||
+                hasAnyCommentsInside(node)) {
+                return false;
+            }
+            const [onlyProperty] = node.properties;
+            return !onlyProperty ? false : !isForbiddenProperty(onlyProperty);
+        };
+        const unwrapExpression = (expression) => {
+            let current = expression;
+            let didUnwrap = true;
+            while (didUnwrap) {
+                didUnwrap = false;
+                switch (current.type) {
+                    case AST_NODE_TYPES$1.ChainExpression:
+                        current = current.expression;
+                        didUnwrap = true;
+                        break;
+                    case AST_NODE_TYPES$1.TSAsExpression:
+                        current = current.expression;
+                        didUnwrap = true;
+                        break;
+                    case AST_NODE_TYPES$1.TSNonNullExpression:
+                        current = current.expression;
+                        didUnwrap = true;
+                        break;
+                    case AST_NODE_TYPES$1.TSTypeAssertion:
+                        current = current.expression;
+                        didUnwrap = true;
+                        break;
+                }
+            }
+            return current;
+        };
+        const getParenthesizedInner = (expression) => {
+            const anyExpression = expression;
+            if (anyExpression?.type === 'ParenthesizedExpression') {
+                const inner = anyExpression.expression;
+                if (inner) {
+                    return inner;
+                }
+            }
+            return null;
+        };
+        const spreadNeedsParens = (argument) => {
+            switch (argument.type) {
+                case AST_NODE_TYPES$1.AssignmentExpression:
+                case AST_NODE_TYPES$1.BinaryExpression:
+                case AST_NODE_TYPES$1.ConditionalExpression:
+                case AST_NODE_TYPES$1.LogicalExpression:
+                case AST_NODE_TYPES$1.SequenceExpression:
+                    return true;
+                default:
+                    return false;
+            }
+        };
+        const renderSpreadOneLine = (argument) => {
+            const argText = sourceCode.getText(argument);
+            return spreadNeedsParens(argument) ? `...(${argText})` : `...${argText}`;
+        };
+        const renderPropertyOneLine = (property) => {
+            if (property.type === AST_NODE_TYPES$1.SpreadElement) {
+                return renderSpreadOneLine(property.argument);
+            }
+            if (property.type !== AST_NODE_TYPES$1.Property ||
+                property.kind !== 'init' ||
+                property.method) {
+                return sourceCode.getText(property);
+            }
+            if (property.shorthand && property.key.type === AST_NODE_TYPES$1.Identifier) {
+                return property.key.name;
+            }
+            const keyText = sourceCode.getText(property.key);
+            const valueExpression = property.value;
+            // eslint-disable-next-line @typescript-eslint/no-use-before-define
+            const valueText = renderExpressionOneLine(valueExpression);
+            if (property.computed) {
+                return `[${keyText}]: ${valueText}`;
+            }
+            return `${keyText}: ${valueText}`;
+        };
+        const renderObjectExpressionOneLine = (node) => {
+            const [onlyProperty] = node.properties;
+            if (!onlyProperty) {
+                return '{}';
+            }
+            return `{${renderPropertyOneLine(onlyProperty)}}`;
+        };
+        const renderExpressionOneLine = (expression) => {
+            const innerParen = getParenthesizedInner(expression);
+            if (innerParen) {
+                const inner = unwrapExpression(innerParen);
+                if (inner.type === AST_NODE_TYPES$1.ObjectExpression &&
+                    canInlineObjectExpression(inner)) {
+                    return `(${renderObjectExpressionOneLine(inner)})`;
+                }
+                return sourceCode.getText(expression);
+            }
+            const unwrapped = unwrapExpression(expression);
+            if (unwrapped.type === AST_NODE_TYPES$1.ObjectExpression &&
+                canInlineObjectExpression(unwrapped)) {
+                return renderObjectExpressionOneLine(unwrapped);
+            }
+            return sourceCode.getText(expression);
+        };
+        const hasPendingInnerInlineCandidate = (node) => {
+            if (node.properties.length !== 1) {
+                return false;
+            }
+            const [onlyElement] = node.properties;
+            if (onlyElement?.type !== AST_NODE_TYPES$1.Property ||
+                onlyElement.kind !== 'init' ||
+                onlyElement.method) {
+                return false;
+            }
+            const rawValue = onlyElement.value;
+            const value = unwrapExpression(rawValue);
+            const innerParen = getParenthesizedInner(value);
+            if (innerParen) {
+                const inner = unwrapExpression(innerParen);
+                if (inner.type === AST_NODE_TYPES$1.ObjectExpression &&
+                    canInlineObjectExpression(inner)) {
+                    const innerText = sourceCode.getText(inner);
+                    return innerText.includes('\n');
+                }
+            }
+            if (value.type === AST_NODE_TYPES$1.ArrowFunctionExpression) {
+                const bodyAny = value.body;
+                if (bodyAny?.type === 'ParenthesizedExpression') {
+                    const bodyInner = bodyAny.expression;
+                    if (bodyInner) {
+                        const inner = unwrapExpression(bodyInner);
+                        if (inner.type === AST_NODE_TYPES$1.ObjectExpression &&
+                            canInlineObjectExpression(inner)) {
+                            const innerText = sourceCode.getText(inner);
+                            return innerText.includes('\n');
+                        }
+                    }
+                }
+                else if (bodyAny && typeof bodyAny === 'object' && 'type' in bodyAny) {
+                    const bodyExpr = unwrapExpression(bodyAny);
+                    if (bodyExpr.type === AST_NODE_TYPES$1.ObjectExpression &&
+                        canInlineObjectExpression(bodyExpr)) {
+                        const innerText = sourceCode.getText(bodyExpr);
+                        return innerText.includes('\n');
+                    }
+                }
+            }
+            return false;
+        };
+        const hasArrowReturningMultiPropObject = (node) => {
+            if (node.properties.length !== 1) {
+                return false;
+            }
+            const [onlyElement] = node.properties;
+            if (onlyElement?.type !== AST_NODE_TYPES$1.Property ||
+                onlyElement.kind !== 'init' ||
+                onlyElement.method) {
+                return false;
+            }
+            const rawValue = onlyElement.value;
+            const value = unwrapExpression(rawValue);
+            if (value.type !== AST_NODE_TYPES$1.ArrowFunctionExpression) {
+                return false;
+            }
+            const bodyAny = value.body;
+            if (bodyAny?.type === 'ParenthesizedExpression') {
+                const innerRaw = bodyAny.expression;
+                if (!innerRaw) {
+                    return false;
+                }
+                const inner = unwrapExpression(innerRaw);
+                return (inner.type === AST_NODE_TYPES$1.ObjectExpression &&
+                    inner.properties.length > 1);
+            }
+            if (bodyAny && typeof bodyAny === 'object' && 'type' in bodyAny) {
+                const inner = unwrapExpression(bodyAny);
+                return (inner.type === AST_NODE_TYPES$1.ObjectExpression &&
+                    inner.properties.length > 1);
+            }
+            return false;
+        };
+        const fitsPrintWidthAfterFix = (node, fixedText) => {
+            if (!node?.loc) {
+                return false;
+            }
+            const startLine = node.loc.start.line;
+            const endLine = node.loc.end.line;
+            const startLineStartIndex = sourceCode.getIndexFromLoc({
+                column: 0,
+                line: startLine,
+            });
+            const endLineStartIndex = sourceCode.getIndexFromLoc({
+                column: 0,
+                line: endLine,
+            });
+            const endLineEndIndex = getLineEndIndex(endLineStartIndex);
+            const nodeStartIndex = node.range[0];
+            const nodeEndIndex = node.range[1];
+            const prefix = sourceCode.text.slice(startLineStartIndex, nodeStartIndex);
+            const suffix = sourceCode.text.slice(nodeEndIndex, endLineEndIndex);
+            const newLineText = `${prefix}${fixedText}${suffix}`;
+            return newLineText.length <= printWidth;
+        };
+        return {
+            ObjectExpression(node) {
+                const originalText = sourceCode.getText(node);
+                if (!canInlineObjectExpression(node) ||
+                    !originalText.includes('\n') ||
+                    hasPendingInnerInlineCandidate(node) ||
+                    hasArrowReturningMultiPropObject(node)) {
+                    return;
+                }
+                const fixedText = renderObjectExpressionOneLine(node);
+                if (!fitsPrintWidthAfterFix(node, fixedText)) {
+                    return;
+                }
+                context.report({
+                    fix(fixer) {
+                        return fixer.replaceText(node, fixedText);
+                    },
+                    messageId: 'oneLine',
+                    node,
+                });
+            },
+        };
+    },
+    defaultOptions: [{ printWidth: 90 }],
+    meta: {
+        docs: {
+            description: 'Enforce single-line formatting for single-property objects when possible (Prettier-friendly)',
+        },
+        fixable: 'whitespace',
+        messages: { oneLine: 'Single-property object should be written in one line' },
+        schema: [
+            {
+                additionalProperties: false,
+                properties: { printWidth: { type: 'number' } },
+                type: 'object',
+            },
+        ],
+        type: 'layout',
+    },
+    name: 'object-single-line',
+});
+
 const MESSAGE_ID$1 = 'prefer-deep-imports';
 const ERROR_MESSAGE = 'Import via root entry point is prohibited when nested entry points exist';
 const createRule$3 = ESLintUtils.RuleCreator(() => ERROR_MESSAGE);
@@ -2714,19 +2907,11 @@ var standaloneImportsSort = createRule$1({
             },
         };
     },
-    defaultOptions: [
-        {
-            decorators: ['Component', 'Directive', 'NgModule', 'Pipe'],
-        },
-    ],
+    defaultOptions: [{ decorators: ['Component', 'Directive', 'NgModule', 'Pipe'] }],
     meta: {
-        docs: {
-            description: 'Sort Angular standalone imports inside decorators.',
-        },
+        docs: { description: 'Sort Angular standalone imports inside decorators.' },
         fixable: 'code',
-        messages: {
-            incorrectOrder: 'Order in imports should be [{{expected}}]',
-        },
+        messages: { incorrectOrder: 'Order in imports should be [{{expected}}]' },
         schema: [
             {
                 additionalProperties: false,
@@ -2857,11 +3042,12 @@ const plugin = {
         'class-property-naming': classPropertyNaming,
         'decorator-key-sort': config$1,
         'flat-exports': flatExports,
-        'injection-token-description': rule$4,
-        'no-deep-imports': rule$3,
+        'injection-token-description': rule$5,
+        'no-deep-imports': rule$4,
         'no-deep-imports-to-indexed-packages': noDeepImportsToIndexedPackages,
         'no-href-with-router-link': config,
-        'no-implicit-public': rule$2,
+        'no-implicit-public': rule$3,
+        'object-single-line': rule$2,
         'prefer-deep-imports': preferDeepImports,
         'short-tui-imports': rule$1,
         'standalone-imports-sort': standaloneImportsSort,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@taiga-ui/eslint-plugin-experience-next",
-  "version": "0.392.0",
+  "version": "0.394.0",
   "description": "An ESLint plugin to enforce a consistent code styles across taiga-ui projects",
   "license": "Apache-2.0",
   "type": "module",
@@ -27,7 +27,7 @@
     "eslint-plugin-import": "^2.32.0",
     "eslint-plugin-jest": "^29.12.1",
     "eslint-plugin-package-json": "^0.88.1",
-    "eslint-plugin-perfectionist": "^5.3.1",
+    "eslint-plugin-perfectionist": "^5.4.0",
     "eslint-plugin-playwright": "^2.5.0",
     "eslint-plugin-prettier": "^5.5.5",
     "eslint-plugin-promise": "^7.2.1",

package/rules/object-single-line.d.ts

@@ -0,0 +1,8 @@
+import { ESLintUtils } from '@typescript-eslint/utils';
+type Options = [{
+    printWidth: number;
+}];
+export declare const rule: ESLintUtils.RuleModule<"oneLine", Options, unknown, ESLintUtils.RuleListener> & {
+    name: string;
+};
+export default rule;