@taiga-ui/eslint-plugin-experience-next 0.526.0 → 0.527.0

package/index.esm.js

@@ -465,8 +465,106 @@ const TUI_MEMBER_ORDERING_CONVENTION = [
     '#private-instance-method',
 ];
 
+function isSingleLineNode(node) {
+    return node.loc.start.line === node.loc.end.line;
+}
+function isLineBreakCharacter(char) {
+    return char === '\n' || char === '\r';
+}
+function hasCommentLikeText(text) {
+    return text.includes('//') || text.includes('/*');
+}
+function hasBlankLine(text) {
+    let lineBreaks = 0;
+    for (let index = 0; index < text.length; index++) {
+        const char = text[index];
+        if (char === '\n') {
+            lineBreaks++;
+        }
+        else if (char === '\r') {
+            lineBreaks++;
+            if (text[index + 1] === '\n') {
+                index++;
+            }
+        }
+        if (lineBreaks > 1) {
+            return true;
+        }
+    }
+    return false;
+}
+function getLineBreak(text) {
+    if (text.includes('\r\n')) {
+        return '\r\n';
+    }
+    return text.includes('\r') ? '\r' : '\n';
+}
+function hasLineBreak(text) {
+    for (const char of text) {
+        if (isLineBreakCharacter(char)) {
+            return true;
+        }
+    }
+    return false;
+}
+function getLeadingIndentation(text) {
+    let index = 0;
+    while (index < text.length && (text[index] === ' ' || text[index] === '\t')) {
+        index++;
+    }
+    return text.slice(0, index);
+}
+function getLineStartOffset(text, offset) {
+    let index = offset - 1;
+    while (index >= 0) {
+        const char = text[index];
+        if (isLineBreakCharacter(char)) {
+            return index + 1;
+        }
+        index--;
+    }
+    return 0;
+}
+function getLineEndOffset(text, lineStartOffset) {
+    let index = lineStartOffset;
+    while (index < text.length) {
+        const char = text[index];
+        if (isLineBreakCharacter(char)) {
+            return index;
+        }
+        index++;
+    }
+    return text.length;
+}
+function getNextLineStartOffset(text, offset) {
+    let index = offset;
+    while (index < text.length) {
+        const char = text[index];
+        if (char === '\r') {
+            return text[index + 1] === '\n' ? index + 2 : index + 1;
+        }
+        if (char === '\n') {
+            return index + 1;
+        }
+        index++;
+    }
+    return offset;
+}
+function splitLines(text) {
+    return text.split(/\r\n|\n|\r/);
+}
+function getIndentAtOffset(text, offset) {
+    const lineStart = getLineStartOffset(text, offset);
+    const indent = text.slice(lineStart, offset);
+    return indent.trim() === '' ? indent : '';
+}
+function getSpacingReplacement(sourceCode, betweenText, nextLine, blankLineCount) {
+    const indentation = getLeadingIndentation(sourceCode.lines[nextLine - 1] ?? '');
+    return `${getLineBreak(betweenText).repeat(blankLineCount + 1)}${indentation}`;
+}
+
 function buildAST(text) {
-    const lines = text.split('\n');
+    const lines = splitLines(text);
     const lastLine = lines[lines.length - 1] ?? '';
     return {
         body: [],
@@ -15096,57 +15194,6 @@ function getClassMemberName(member) {
         : getStaticPropertyName(member.key);
 }
 
-function isSingleLineNode(node) {
-    return node.loc.start.line === node.loc.end.line;
-}
-function hasCommentLikeText(text) {
-    return text.includes('//') || text.includes('/*');
-}
-function hasBlankLine(text) {
-    let lineBreaks = 0;
-    for (let index = 0; index < text.length; index++) {
-        const char = text[index];
-        if (char === '\n') {
-            lineBreaks++;
-        }
-        else if (char === '\r') {
-            lineBreaks++;
-            if (text[index + 1] === '\n') {
-                index++;
-            }
-        }
-        if (lineBreaks > 1) {
-            return true;
-        }
-    }
-    return false;
-}
-function getLineBreak(text) {
-    if (text.includes('\r\n')) {
-        return '\r\n';
-    }
-    return text.includes('\r') ? '\r' : '\n';
-}
-function getLeadingIndentation(text) {
-    let index = 0;
-    while (index < text.length && (text[index] === ' ' || text[index] === '\t')) {
-        index++;
-    }
-    return text.slice(0, index);
-}
-function getLineStartOffset(text, offset) {
-    return text.lastIndexOf('\n', offset - 1) + 1;
-}
-function getIndentAtOffset(text, offset) {
-    const lineStart = getLineStartOffset(text, offset);
-    const indent = text.slice(lineStart, offset);
-    return indent.trim() === '' ? indent : '';
-}
-function getSpacingReplacement(sourceCode, betweenText, nextLine, blankLineCount) {
-    const indentation = getLeadingIndentation(sourceCode.lines[nextLine - 1] ?? '');
-    return `${getLineBreak(betweenText).repeat(blankLineCount + 1)}${indentation}`;
-}
-
 const RULE_DOCS_BASE_URL = 'https://github.com/taiga-family/toolkit/tree/main/projects/eslint-plugin-experience-next/docs';
 const ruleCreator = dist$4.ESLintUtils.RuleCreator((name) => `${RULE_DOCS_BASE_URL}/${name}.md`);
 function createRule(options) {
@@ -248017,13 +248064,14 @@ function buildMultilineStartTag(node, sourceText) {
     const closing = sourceText
         .slice(lastAttr ? lastAttr.sourceSpan.end.offset : startTag.end.offset, startTag.end.offset)
         .trimStart();
+    const lineBreak = getLineBreak(sourceText);
     return [
         tagStart.trimEnd(),
         ...attrs.map((attr) => sourceText
             .slice(attr.sourceSpan.start.offset, attr.sourceSpan.end.offset)
             .trim()),
         closing,
-    ].join('\n');
+    ].join(lineBreak);
 }
 const rule$W = createRule({
     name: 'attrs-newline',
@@ -248301,6 +248349,7 @@ const rule$U = createRule({
     name: 'element-newline',
     rule: {
         create(context) {
+            const lineBreak = getLineBreak(context.sourceCode.getText());
             return {
                 Element(rawNode) {
                     const node = rawNode;
@@ -248321,7 +248370,7 @@ const rule$U = createRule({
                             fix: (fixer) => fixer.insertTextBeforeRange([
                                 firstChild.sourceSpan.start.offset,
                                 firstChild.sourceSpan.start.offset,
-                            ], '\n'),
+                            ], lineBreak),
                             loc: sourceSpanToLoc(firstChild.sourceSpan),
                             messageId: MESSAGE_ID$i,
                         });
@@ -248339,7 +248388,7 @@ const rule$U = createRule({
                                 fix: (fixer) => fixer.insertTextAfterRange([
                                     child.sourceSpan.end.offset,
                                     child.sourceSpan.end.offset,
-                                ], '\n'),
+                                ], lineBreak),
                                 loc: sourceSpanToLoc(next.sourceSpan),
                                 messageId: MESSAGE_ID$i,
                             });
@@ -248353,7 +248402,7 @@ const rule$U = createRule({
                             fix: (fixer) => fixer.insertTextAfterRange([
                                 lastChild.sourceSpan.end.offset,
                                 lastChild.sourceSpan.end.offset,
-                            ], '\n'),
+                            ], lineBreak),
                             loc: sourceSpanToLoc(lastChild.sourceSpan),
                             messageId: MESSAGE_ID$i,
                         });
@@ -248644,19 +248693,21 @@ function getAttachedComments(hostObject, properties, sourceCode, comments) {
     return usedComments.size === comments.length ? attached : null;
 }
 function renderFixWithComments(hostObject, sortedProperties, sourceCode, attachedComments) {
+    const lineBreak = getLineBreak(sourceCode.text);
     const objectIndentation = getLineIndentation(sourceCode.text, hostObject.range[0]);
     const propertyIndentation = getPropertyIndentation(hostObject, sortedProperties, sourceCode.text, attachedComments);
-    return `{\n${sortedProperties
+    return `{${lineBreak}${sortedProperties
         .map(({ node }, index) => renderPropertyWithComments(node, attachedComments.get(node), sourceCode, propertyIndentation, index === sortedProperties.length - 1))
-        .join('\n')}\n${objectIndentation}}`;
+        .join(lineBreak)}${lineBreak}${objectIndentation}}`;
 }
 function renderPropertyWithComments(property, attachedComments, sourceCode, propertyIndentation, isLast) {
+    const lineBreak = getLineBreak(sourceCode.text);
     const lines = attachedComments?.leading.map((comment) => `${propertyIndentation}${sourceCode.text.slice(...comment.range)}`) ?? [];
     const trailingComment = attachedComments?.trailing
         ? ` ${sourceCode.text.slice(...attachedComments.trailing.range)}`
         : '';
     lines.push(`${propertyIndentation}${sourceCode.getText(property)}${isLast ? '' : ','}${trailingComment}`);
-    return lines.join('\n');
+    return lines.join(lineBreak);
 }
 function getPropertyIndentation(hostObject, properties, sourceText, attachedComments) {
     for (const { node } of properties) {
@@ -248670,9 +248721,7 @@ function getPropertyIndentation(hostObject, properties, sourceText, attachedComm
 }
 function getLineIndentation(sourceText, offset) {
     let lineStart = offset;
-    while (lineStart > 0 &&
-        sourceText[lineStart - 1] !== '\n' &&
-        sourceText[lineStart - 1] !== '\r') {
+    while (lineStart > 0 && !isLineBreakCharacter(sourceText[lineStart - 1])) {
         lineStart--;
     }
     let indentationEnd = lineStart;
@@ -249382,11 +249431,15 @@ const rule$R = createRule({
         }
         function buildImportRemovalFix(fixer, node) {
             const [start, end] = node.range;
-            const lineStart = sourceCode.text.lastIndexOf('\n', start - 1) + 1;
+            const lineStart = getLineStartOffset(sourceCode.text, start);
             const removeStart = /^\s*$/.test(sourceCode.text.slice(lineStart, start))
                 ? lineStart
                 : start;
-            const removeEnd = sourceCode.text[end] === '\n' ? end + 1 : end;
+            const lineEnd = getLineEndOffset(sourceCode.text, end);
+            const isImportLastStatementOnLine = sourceCode.text.slice(end, lineEnd).trim() === '';
+            const removeEnd = isImportLastStatementOnLine
+                ? getNextLineStartOffset(sourceCode.text, end)
+                : end;
             return [fixer.removeRange([removeStart, removeEnd])];
         }
         function buildDuplicateImportFix(fixer, first, rest) {
@@ -249700,7 +249753,7 @@ const rule$R = createRule({
                 const relPath = computeRelativeImportPath(context.filename, sourceFilePath);
                 newImports.push(`${importPrefix} {${names.join(', ')}} from ${quote}${relPath}${quote}${semi}`);
             }
-            return newImports.join('\n');
+            return newImports.join(getLineBreak(sourceCode.text));
         }
         function checkDefaultImport(node) {
             if ((!checkDefaultImports &&
@@ -250050,17 +250103,18 @@ function getDescriptionNode(node) {
 function prependTokenName(text, name) {
     return `${text.slice(0, 1)}[${name}]: ${text.slice(1)}`;
 }
-function getNgDevModeDeclarationFix(program, fixer) {
+function getNgDevModeDeclarationFix(program, fixer, sourceCode) {
     const lastImport = [...program.body]
         .reverse()
         .find((statement) => statement.type === dist$3.AST_NODE_TYPES.ImportDeclaration);
+    const lineBreak = getLineBreak(sourceCode.text);
     if (lastImport) {
-        return fixer.insertTextAfter(lastImport, '\n\ndeclare const ngDevMode: boolean;');
+        return fixer.insertTextAfter(lastImport, `${lineBreak}${lineBreak}declare const ngDevMode: boolean;`);
     }
     const [firstStatement] = program.body;
     return firstStatement
-        ? fixer.insertTextBefore(firstStatement, 'declare const ngDevMode: boolean;\n\n')
-        : fixer.insertTextBeforeRange([0, 0], 'declare const ngDevMode: boolean;\n');
+        ? fixer.insertTextBefore(firstStatement, `declare const ngDevMode: boolean;${lineBreak}${lineBreak}`)
+        : fixer.insertTextBeforeRange([0, 0], `declare const ngDevMode: boolean;${lineBreak}`);
 }
 const rule$Q = createRule({
     create(context) {
@@ -250090,7 +250144,7 @@ const rule$Q = createRule({
                                 shouldAddNgDevModeDeclaration &&
                                 !hasVariableInScope(sourceCode, description, NG_DEV_MODE)) {
                                 shouldAddNgDevModeDeclaration = false;
-                                fixes.unshift(getNgDevModeDeclarationFix(program, fixer));
+                                fixes.unshift(getNgDevModeDeclarationFix(program, fixer, sourceCode));
                             }
                             return fixes;
                         },
@@ -250708,11 +250762,10 @@ function getSinglePropertyRange(text, property) {
         : [property.range[0], property.range[1]];
 }
 function getLineStart(text, index) {
-    return text.lastIndexOf('\n', index - 1) + 1;
+    return getLineStartOffset(text, index);
 }
 function getNextLineStart(text, index) {
-    const lineEnd = text.indexOf('\n', index);
-    return lineEnd === -1 ? index : lineEnd + 1;
+    return getNextLineStartOffset(text, index);
 }
 function hasCommentsInRange(sourceCode, [start, end]) {
     return sourceCode
@@ -251322,7 +251375,7 @@ const rule$D = createRule({
         return {
             Program(node) {
                 const text = context.sourceCode.getText(node);
-                const lines = text.split('\n');
+                const lines = splitLines(text);
                 for (const [index, line] of lines.entries()) {
                     const trimmed = line.trim();
                     if (!trimmed || trimmed.startsWith('#') || trimmed.startsWith(';')) {
@@ -251664,11 +251717,12 @@ const rule$B = createRule({
                                     return null;
                                 }
                                 const indent = getIndentAtOffset(sourceCode.text, insertOffset);
+                                const lineBreak = getLineBreak(sourceCode.text);
                                 const declarations = result.lets
                                     .map(({ expression, name }, index) => `${index === 0 ? '' : indent}@let ${name} = ${expression};`)
-                                    .join('\n');
+                                    .join(lineBreak);
                                 return [
-                                    fixer.insertTextBeforeRange([insertOffset, insertOffset], `${declarations}\n${indent}`),
+                                    fixer.insertTextBeforeRange([insertOffset, insertOffset], `${declarations}${lineBreak}${indent}`),
                                     fixer.replaceTextRange([node.sourceSpan.start, node.sourceSpan.end], result.reference),
                                 ];
                             },
@@ -252664,10 +252718,11 @@ const rule$v = createRule({
                     fix(fixer) {
                         const varName = getCalleeName(firstCall);
                         const parentStatement = findParentStatement(node);
+                        const lineBreak = getLineBreak(sourceCode.text);
                         if (parentStatement) {
                             const indent = getStatementIndent$1(parentStatement, sourceCode.text);
                             const fixes = [
-                                fixer.insertTextBefore(parentStatement, `const ${varName} = ${callText};\n\n${indent}`),
+                                fixer.insertTextBefore(parentStatement, `const ${varName} = ${callText};${lineBreak}${lineBreak}${indent}`),
                             ];
                             for (const call of calls) {
                                 fixes.push(fixer.replaceText(getTargetNode(call), varName));
@@ -252694,7 +252749,7 @@ const rule$v = createRule({
                             lastIndex = end;
                         }
                         replacedBody += bodyText.slice(lastIndex);
-                        const newBody = `{\n${innerIndent}const ${varName} = ${callText};\n\n${innerIndent}return ${replacedBody};\n${outerIndent}}`;
+                        const newBody = `{${lineBreak}${innerIndent}const ${varName} = ${callText};${lineBreak}${lineBreak}${innerIndent}return ${replacedBody};${lineBreak}${outerIndent}}`;
                         const bodyRangeStart = arrowBody.range[0];
                         const textBeforeBody = sourceCode.text.slice(0, bodyRangeStart);
                         const whitespaceBeforeBody = /\s*$/.exec(textBeforeBody)?.[0] ?? '';
@@ -253146,6 +253201,10 @@ const rule$s = createUntrackedRule({
     name: 'no-signal-reads-after-await-in-reactive-context',
 });
 
+const CARRIAGE_RETURN = String.fromCharCode(13);
+const LINE_FEED = String.fromCharCode(10);
+const ESCAPED_CARRIAGE_RETURN = String.fromCharCode(92, 114);
+const ESCAPED_LINE_FEED = String.fromCharCode(92, 110);
 function collectParts(node) {
     return node.type === dist$4.AST_NODE_TYPES.BinaryExpression && node.operator === '+'
         ? [...collectParts(node.left), ...collectParts(node.right)]
@@ -253165,8 +253224,8 @@ function buildMergedString(parts) {
     const quote = combined.includes("'") && !combined.includes('"') ? '"' : "'";
     const escaped = combined
         .replaceAll('\\', '\\\\')
-        .replaceAll('\r', String.raw `\r`)
-        .replaceAll('\n', String.raw `\n`)
+        .replaceAll(CARRIAGE_RETURN, ESCAPED_CARRIAGE_RETURN)
+        .replaceAll(LINE_FEED, ESCAPED_LINE_FEED)
         .replaceAll('\t', String.raw `\t`)
         .replaceAll(new RegExp(quote, 'g'), `\\${quote}`);
     return `${quote}${escaped}${quote}`;
@@ -253300,13 +253359,14 @@ function findUntrackedAlias(program) {
  * Builds fixer actions that add `untracked` to an existing `@angular/core` import,
  * or insert a new import declaration when none exists.
  */
-function buildUntrackedImportFixes(program, fixer) {
+function buildUntrackedImportFixes(program, fixer, sourceCode) {
     const coreImport = findRuntimeAngularCoreImport(program);
+    const lineBreak = getLineBreak(sourceCode.text);
     if (!coreImport) {
         const firstStatement = program.body[0];
         return firstStatement
             ? [
-                fixer.insertTextBefore(firstStatement, "import { untracked } from '@angular/core';\n"),
+                fixer.insertTextBefore(firstStatement, `import { untracked } from '@angular/core';${lineBreak}`),
             ]
             : [];
     }
@@ -253321,7 +253381,7 @@ function buildUntrackedImportFixes(program, fixer) {
     return defaultImport
         ? [fixer.insertTextAfter(defaultImport, ', { untracked }')]
         : [
-            fixer.insertTextAfter(coreImport, "\nimport { untracked } from '@angular/core';"),
+            fixer.insertTextAfter(coreImport, `${lineBreak}import { untracked } from '@angular/core';`),
         ];
 }
 /**
@@ -253411,10 +253471,9 @@ function dedent(text, extraSpaces) {
         return text;
     }
     const prefix = ' '.repeat(extraSpaces);
-    return text
-        .split('\n')
+    return splitLines(text)
         .map((line) => (line.startsWith(prefix) ? line.slice(extraSpaces) : line))
-        .join('\n');
+        .join(getLineBreak(text));
 }
 
 function isDirectCallOrNewArgument(node) {
@@ -253617,7 +253676,8 @@ function buildReplacement(untrackedCall, parentStatement, sourceCode) {
         const firstStmtColumn = firstStmt.loc.start.column;
         const extra = firstStmtColumn - parentColumn;
         const indented = stmts.map((s) => dedent(sourceCode.getText(s), extra));
-        return indented.join(`\n${''.padStart(parentColumn)}`);
+        const lineBreak = getLineBreak(sourceCode.text);
+        return indented.join(`${lineBreak}${''.padStart(parentColumn)}`);
     }
     // Expression body: arrow `() => expr` — just emit `expr;`
     return `${sourceCode.getText(body)};`;
@@ -253728,14 +253788,7 @@ const rule$p = createUntrackedRule({
 const rule$o = createRule({
     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;
-            return rawEndIndex > lineStartIndex && text[rawEndIndex - 1] === '\r'
-                ? rawEndIndex - 1
-                : rawEndIndex;
-        };
+        const getLineEndIndex = (lineStartIndex) => getLineEndOffset(sourceCode.text, lineStartIndex);
         const hasAnyCommentsInside = (node) => sourceCode.getCommentsInside(node).length > 0;
         const isTemplateLikeExpression = (expression) => expression.type === dist$3.AST_NODE_TYPES.TemplateLiteral ||
             expression.type === dist$3.AST_NODE_TYPES.TaggedTemplateExpression;
@@ -253847,7 +253900,7 @@ const rule$o = createRule({
                 if (inner.type === dist$3.AST_NODE_TYPES.ObjectExpression &&
                     canInlineObjectExpression(inner)) {
                     const innerText = sourceCode.getText(inner);
-                    return innerText.includes('\n');
+                    return hasLineBreak(innerText);
                 }
             }
             if (value.type === dist$3.AST_NODE_TYPES.ArrowFunctionExpression) {
@@ -253859,7 +253912,7 @@ const rule$o = createRule({
                         if (inner.type === dist$3.AST_NODE_TYPES.ObjectExpression &&
                             canInlineObjectExpression(inner)) {
                             const innerText = sourceCode.getText(inner);
-                            return innerText.includes('\n');
+                            return hasLineBreak(innerText);
                         }
                     }
                 }
@@ -253868,7 +253921,7 @@ const rule$o = createRule({
                     if (bodyExpr.type === dist$3.AST_NODE_TYPES.ObjectExpression &&
                         canInlineObjectExpression(bodyExpr)) {
                         const innerText = sourceCode.getText(bodyExpr);
-                        return innerText.includes('\n');
+                        return hasLineBreak(innerText);
                     }
                 }
             }
@@ -253932,7 +253985,7 @@ const rule$o = createRule({
             ObjectExpression(node) {
                 const originalText = sourceCode.getText(node);
                 if (!canInlineObjectExpression(node) ||
-                    !originalText.includes('\n') ||
+                    !hasLineBreak(originalText) ||
                     hasPendingInnerInlineCandidate(node) ||
                     hasArrowReturningMultiPropObject(node)) {
                     return;
@@ -254306,35 +254359,37 @@ function renderConditionalReturn(ifStatement, consequentExpression, alternateExp
         return inlineReturn;
     }
     const branchIndent = `${indent}    `;
-    return `return ${test}\n${branchIndent}? ${consequent}\n${branchIndent}: ${alternate};`;
+    const lineBreak = getLineBreak(sourceCode.text);
+    return `return ${test}${lineBreak}${branchIndent}? ${consequent}${lineBreak}${branchIndent}: ${alternate};`;
 }
 function renderBooleanTestReturn(ifStatement, sourceCode, strategy) {
     const test = sourceCode.getText(ifStatement.test);
+    const lineBreak = getLineBreak(sourceCode.text);
     if (strategy === 'negate') {
-        if (!test.includes('\n')) {
+        if (!hasLineBreak(test)) {
             const renderedTest = needsParenthesesInBooleanCoercion(ifStatement.test)
                 ? `(${test})`
                 : test;
             return `return !${renderedTest};`;
         }
         const indent = getStatementIndent(ifStatement, sourceCode);
-        return `return !(\n${indent}    ${test}\n${indent});`;
+        return `return !(${lineBreak}${indent}    ${test}${lineBreak}${indent});`;
     }
     if (strategy === 'coerce') {
-        if (!test.includes('\n')) {
+        if (!hasLineBreak(test)) {
             const renderedTest = needsParenthesesInBooleanCoercion(ifStatement.test)
                 ? `(${test})`
                 : test;
             return `return !!${renderedTest};`;
         }
         const indent = getStatementIndent(ifStatement, sourceCode);
-        return `return !!(\n${indent}    ${test}\n${indent});`;
+        return `return !!(${lineBreak}${indent}    ${test}${lineBreak}${indent});`;
     }
-    if (!test.includes('\n')) {
+    if (!hasLineBreak(test)) {
         return `return ${test};`;
     }
     const indent = getStatementIndent(ifStatement, sourceCode);
-    return `return (\n${indent}    ${test}\n${indent});`;
+    return `return (${lineBreak}${indent}    ${test}${lineBreak}${indent});`;
 }
 const rule$m = createRule({
     create(context) {
@@ -254912,7 +254967,7 @@ const rule$i = createUntrackedRule({
                 ? (fixer) => [fixer.replaceText(read, wrapped)]
                 : (fixer) => [
                     fixer.replaceText(read, wrapped),
-                    ...buildUntrackedImportFixes(program, fixer),
+                    ...buildUntrackedImportFixes(program, fixer, sourceCode),
                 ];
         }
         return {
@@ -255051,8 +255106,7 @@ const rule$g = createRule({
                         let openQuoteOffset = valueSpan.start.offset - 1;
                         while (openQuoteOffset >= 0 &&
                             (sourceText[openQuoteOffset] === ' ' ||
-                                sourceText[openQuoteOffset] === '\n' ||
-                                sourceText[openQuoteOffset] === '\r' ||
+                                isLineBreakCharacter(sourceText[openQuoteOffset]) ||
                                 sourceText[openQuoteOffset] === '\t')) {
                             openQuoteOffset--;
                         }
@@ -255063,8 +255117,7 @@ const rule$g = createRule({
                         if (isQuotedAttribute) {
                             while (closeQuoteOffset < sourceText.length &&
                                 (sourceText[closeQuoteOffset] === ' ' ||
-                                    sourceText[closeQuoteOffset] === '\n' ||
-                                    sourceText[closeQuoteOffset] === '\r' ||
+                                    isLineBreakCharacter(sourceText[closeQuoteOffset]) ||
                                     sourceText[closeQuoteOffset] === '\t')) {
                                 closeQuoteOffset++;
                             }
@@ -255121,6 +255174,7 @@ const rule$f = createRule({
     rule: {
         create(context) {
             const sourceText = context.sourceCode.getText();
+            const lineBreak = getLineBreak(sourceText);
             let reported = false;
             return {
                 Element(rawNode) {
@@ -255132,7 +255186,7 @@ const rule$f = createRule({
                     }
                     reported = true;
                     context.report({
-                        fix: (fixer) => fixer.insertTextBeforeRange([0, 0], '<!DOCTYPE html>\n'),
+                        fix: (fixer) => fixer.insertTextBeforeRange([0, 0], `<!DOCTYPE html>${lineBreak}`),
                         loc: sourceSpanToLoc(node.startSourceSpan),
                         messageId: MESSAGE_ID$6,
                     });
@@ -256766,7 +256820,7 @@ function buildRewrittenImports({ baseImportPath, node, state, symbolToEntryPoint
     if (remainingImportStatement) {
         importStatements.push(remainingImportStatement);
     }
-    return importStatements.join('\n');
+    return importStatements.join(getLineBreak(state.sourceCode.text));
 }
 function buildNamedImportStatement({ importKind, importPath, specifiers, state, }) {
     const importKeyword = importKind === 'type' ? 'import type' : 'import';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@taiga-ui/eslint-plugin-experience-next",
-  "version": "0.526.0",
+  "version": "0.527.0",
   "description": "An ESLint plugin to enforce a consistent code styles across taiga-ui projects",
   "homepage": "https://github.com/taiga-family/toolkit#readme",
   "bugs": {
@@ -54,10 +54,10 @@
     "eslint-plugin-unicorn": "64.0.0",
     "eslint-plugin-unused-imports": "4.4.1",
     "globals": "17.6.0",
-    "typescript-eslint": "8.59.1"
+    "typescript-eslint": "8.59.2"
   },
   "devDependencies": {
-    "@typescript-eslint/rule-tester": "8.59.1"
+    "@typescript-eslint/rule-tester": "8.59.2"
   },
   "peerDependencies": {
     "eslint": "^9.39.4"

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

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

package/rules/utils/angular/import-fix-helpers.d.ts

@@ -6,7 +6,7 @@ export declare function findUntrackedAlias(program: TSESTree.Program): string |
  * Builds fixer actions that add `untracked` to an existing `@angular/core` import,
  * or insert a new import declaration when none exists.
  */
-export declare function buildUntrackedImportFixes(program: TSESTree.Program, fixer: RuleFixer): Array<ReturnType<RuleFixer['insertTextBefore']>>;
+export declare function buildUntrackedImportFixes(program: TSESTree.Program, fixer: RuleFixer, sourceCode: SourceCode): Array<ReturnType<RuleFixer['insertTextBefore']>>;
 /**
  * Removes the `untracked` import specifier from `@angular/core`.
  * When it is the last specifier, removes the entire declaration.

package/rules/utils/ast/spacing.d.ts

@@ -1,9 +1,14 @@
 import { type TSESLint, type TSESTree } from '@typescript-eslint/utils';
 export declare function isSingleLineNode(node: TSESTree.Node): boolean;
+export declare function isLineBreakCharacter(char: string | undefined): boolean;
 export declare function hasCommentLikeText(text: string): boolean;
 export declare function hasBlankLine(text: string): boolean;
 export declare function getLineBreak(text: string): string;
+export declare function hasLineBreak(text: string): boolean;
 export declare function getLeadingIndentation(text: string): string;
 export declare function getLineStartOffset(text: string, offset: number): number;
+export declare function getLineEndOffset(text: string, lineStartOffset: number): number;
+export declare function getNextLineStartOffset(text: string, offset: number): number;
+export declare function splitLines(text: string): string[];
 export declare function getIndentAtOffset(text: string, offset: number): string;
 export declare function getSpacingReplacement(sourceCode: Readonly<TSESLint.SourceCode>, betweenText: string, nextLine: number, blankLineCount: number): string;