ignore-lint-errors 0.5.0 → 0.7.0

package/README.md

@@ -34,7 +34,7 @@ Step 2. Fix formatting.
 
 ```sh
 # Run prettier
-pnpm format
+pnpm prettier . --write
 ```
 
 

package/dist/src/steps/create-options.js

@@ -7,8 +7,7 @@ function findDependencies(projectRoot) {
     ]);
     return {
         eslint: projectDependencies.has('eslint'),
-        glint: projectDependencies.has('@glint/core') ||
-            projectDependencies.has('@glint/ember-tsc'),
+        glint: projectDependencies.has('@glint/ember-tsc'),
         stylelint: projectDependencies.has('stylelint'),
         typescript: projectDependencies.has('typescript'),
     };

package/dist/src/utils/ignore-errors/eslint.js

@@ -1,44 +1,22 @@
 import { EOL } from 'node:os';
-import { AST } from '@codemod-utils/ast-javascript';
-function getIgnoredEslintRules(lineOfCode) {
-    const traverse = AST.traverse(true);
-    let ignoredEslintRules = [];
-    try {
-        traverse(lineOfCode, {
-            visitComment(node) {
-                // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
-                const comment = node.value.value.trim();
-                if (comment.startsWith('eslint-disable-next-line')) {
-                    ignoredEslintRules = comment
-                        .replace(/^eslint-disable-next-line\s+/, '')
-                        .split(',')
-                        .map((token) => token.trim());
-                }
-                return false;
-            },
-        });
-    }
-    catch {
-        // Do nothing
-    }
-    return ignoredEslintRules;
-}
+import { getIgnoredRules } from './shared/index.js';
 export function ignoreErrors(file, lintErrors) {
     const lines = file.split(EOL);
+    const ignoreDirective = 'eslint-disable-next-line';
     lintErrors.forEach(({ line, message }) => {
         const currentIndex = line - 1;
         const previousIndex = Math.max(currentIndex - 1, 0);
-        const ignoredEslintRules = getIgnoredEslintRules(lines[previousIndex]);
-        if (ignoredEslintRules.length === 0) {
-            const ignoreDirective = `// eslint-disable-next-line ${message}`;
-            lines.splice(currentIndex, 0, ignoreDirective);
+        const ignoredRules = getIgnoredRules(lines[previousIndex], {
+            ignoreDirective,
+        });
+        if (ignoredRules.length === 0) {
+            lines.splice(currentIndex, 0, `// ${ignoreDirective} ${message}`);
         }
         else {
-            const newMessage = [...ignoredEslintRules, ...message.split(', ')]
+            const newMessage = [...ignoredRules, ...message.split(', ')]
                 .sort()
                 .join(', ');
-            const ignoreDirective = `// eslint-disable-next-line ${newMessage}`;
-            lines.splice(previousIndex, 1, ignoreDirective);
+            lines.splice(previousIndex, 1, `// ${ignoreDirective} ${newMessage}`);
         }
     });
     return lines.join(EOL);

package/dist/src/utils/ignore-errors/shared/index.js

@@ -0,0 +1,24 @@
+import { AST } from '@codemod-utils/ast-javascript';
+export function getIgnoredRules(lineOfCode, options) {
+    const traverse = AST.traverse(true);
+    let ignoredRules = [];
+    try {
+        traverse(lineOfCode, {
+            visitComment(node) {
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+                const comment = node.value.value.trim();
+                if (comment.startsWith(options.ignoreDirective)) {
+                    ignoredRules = comment
+                        .replace(new RegExp(`^${options.ignoreDirective}\\s+`, 'g'), '')
+                        .split(',')
+                        .map((token) => token.trim());
+                }
+                return false;
+            },
+        });
+    }
+    catch {
+        // Do nothing
+    }
+    return ignoredRules;
+}

package/dist/src/utils/ignore-errors/stylelint.js

@@ -1,9 +1,23 @@
 import { EOL } from 'node:os';
+import { getIgnoredRules } from './shared/index.js';
 export function ignoreErrors(file, lintErrors) {
     const lines = file.split(EOL);
+    const ignoreDirective = 'stylelint-disable-next-line';
     lintErrors.forEach(({ line, message }) => {
-        const ignoreDirective = `/* stylelint-disable-next-line ${message} */`;
-        lines.splice(line - 1, 0, ignoreDirective);
+        const currentIndex = line - 1;
+        const previousIndex = Math.max(currentIndex - 1, 0);
+        const ignoredRules = getIgnoredRules(lines[previousIndex], {
+            ignoreDirective,
+        });
+        if (ignoredRules.length === 0) {
+            lines.splice(currentIndex, 0, `/* ${ignoreDirective} ${message} */`);
+        }
+        else {
+            const newMessage = [...ignoredRules, ...message.split(', ')]
+                .sort()
+                .join(', ');
+            lines.splice(previousIndex, 1, `/* ${ignoreDirective} ${newMessage} */`);
+        }
     });
     return lines.join(EOL);
 }

package/dist/src/utils/ignore-errors/typescript.js

@@ -1,56 +1,92 @@
 import { EOL } from 'node:os';
 import { AST } from '@codemod-utils/ast-template';
-import { findTemplateTags, updateTemplates, } from '@codemod-utils/ast-template-tag';
-export function findLinesWithTemplate(file) {
+import { findTemplateTags as upstreamFindTemplateTags, updateTemplates, } from '@codemod-utils/ast-template-tag';
+import { getIgnoredRules } from './shared/index.js';
+function findTemplateTags(file) {
     function getLOC(file) {
         const matches = file.match(/\r?\n/g);
         return (matches ?? []).length;
     }
-    const templateTags = findTemplateTags(file);
-    const linesWithTemplate = [];
-    templateTags.forEach((templateTag) => {
-        const { range } = templateTag;
+    const templateTags = upstreamFindTemplateTags(file);
+    return templateTags.map((templateTag) => {
+        const { contents, range } = templateTag;
         const lineStart = getLOC(file.substring(0, range.startChar)) + 1;
         const lineEnd = getLOC(file.substring(0, range.endChar)) + 1;
-        linesWithTemplate.push([lineStart, lineEnd]);
+        const lineRange = {
+            end: lineEnd,
+            start: lineStart,
+        };
+        return {
+            contents,
+            lineRange,
+        };
     });
-    return linesWithTemplate;
 }
 export function ignoreErrors(file, lintErrors) {
-    const linesWithTemplate = findLinesWithTemplate(file);
     const lines = file.split(EOL);
+    const templateTags = findTemplateTags(file);
     lintErrors.forEach(({ line, message }) => {
-        const erroredInTemplate = linesWithTemplate.some(([lineStart, lineEnd]) => {
-            return lineStart <= line && line <= lineEnd;
+        const currentIndex = line - 1;
+        const previousIndex = Math.max(currentIndex - 1, 0);
+        const templateTagIndex = templateTags.findIndex(({ lineRange }) => {
+            return lineRange.start <= line && line <= lineRange.end;
+        });
+        const erroredInTemplate = templateTagIndex >= 0;
+        if (erroredInTemplate) {
+            const ignoreDirective = `{{! @glint-expect-error: ${message} }}`;
+            const { contents, lineRange } = templateTags[templateTagIndex];
+            if (lineRange.start !== lineRange.end) {
+                lines.splice(currentIndex, 0, ignoreDirective);
+                return;
+            }
+            const newTemplate = lines[currentIndex].replace(/<template>(.+)<\/template>/, `<template>${ignoreDirective}${contents}</template>`);
+            lines.splice(currentIndex, 1, newTemplate);
+            return;
+        }
+        const ignoreDirective = `// @ts-expect-error: ${message}`;
+        const ignoredRules = getIgnoredRules(lines[previousIndex], {
+            ignoreDirective: 'eslint-disable-next-line',
         });
-        const ignoreDirective = erroredInTemplate
-            ? `{{! @glint-expect-error: ${message} }}`
-            : `// @ts-expect-error: ${message}`;
-        lines.splice(line - 1, 0, ignoreDirective);
+        if (ignoredRules.length === 0) {
+            lines.splice(currentIndex, 0, ignoreDirective);
+        }
+        else {
+            lines.splice(previousIndex, 0, ignoreDirective);
+        }
     });
     return lines.join(EOL);
 }
 // For fallback, ignore type checks in templates
 export function ignoreErrorsFallback(file, lintErrors) {
-    const linesWithTemplate = findLinesWithTemplate(file);
     const lines = file.split(EOL);
+    const templateTags = findTemplateTags(file);
     let hasErrorInTemplate = false;
     lintErrors.forEach(({ line, message }) => {
-        const erroredInTemplate = linesWithTemplate.some(([lineStart, lineEnd]) => {
-            return lineStart <= line && line <= lineEnd;
+        const currentIndex = line - 1;
+        const previousIndex = Math.max(currentIndex - 1, 0);
+        const erroredInTemplate = templateTags.some(({ lineRange }) => {
+            return lineRange.start <= line && line <= lineRange.end;
         });
         if (erroredInTemplate) {
             hasErrorInTemplate = true;
             return;
         }
         const ignoreDirective = `// @ts-expect-error: ${message}`;
-        lines.splice(line - 1, 0, ignoreDirective);
+        const ignoredRules = getIgnoredRules(lines[previousIndex], {
+            ignoreDirective: 'eslint-disable-next-line',
+        });
+        if (ignoredRules.length === 0) {
+            lines.splice(currentIndex, 0, ignoreDirective);
+        }
+        else {
+            lines.splice(previousIndex, 0, ignoreDirective);
+        }
     });
     let newFile = lines.join(EOL);
     if (hasErrorInTemplate) {
         newFile = updateTemplates(newFile, (code) => {
             const ignoreDirective = '{{! @glint-nocheck }}';
-            return [ignoreDirective, code].join(EOL);
+            return [ignoreDirective, code].join('');
         });
     }
     return newFile;
@@ -60,8 +96,8 @@ export function isParseable(file) {
     let isParseable = true;
     try {
         const templateTags = findTemplateTags(file);
-        templateTags.forEach((templateTag) => {
-            traverse(templateTag.contents);
+        templateTags.forEach(({ contents }) => {
+            traverse(contents);
         });
     }
     catch {

package/dist/src/utils/linters/eslint.js

@@ -1,48 +1,31 @@
 import { relative, sep } from 'node:path';
+import { getFilesWithErrors } from './shared/index.js';
 export const outputFilePath = '.ignore-lint-errors/eslint.txt';
-export function parseOutputFile(file, projectRoot) {
+function normalize(file, projectRoot) {
     const filePathToData = new Map();
     const records = JSON.parse(file);
     records.forEach((record) => {
         const { filePath: absoluteFilePath, messages } = record;
+        const filePath = relative(projectRoot, absoluteFilePath).replaceAll(sep, '/');
+        const lineToRules = new Map();
         const data = new Map();
         messages.forEach(({ line, ruleId }) => {
-            if (data.has(line)) {
-                data.get(line).push(ruleId);
+            if (lineToRules.has(line)) {
+                lineToRules.get(line).push(ruleId);
             }
             else {
-                data.set(line, [ruleId]);
-            }
-        });
-        const filePath = relative(projectRoot, absoluteFilePath).replaceAll(sep, '/');
-        filePathToData.set(filePath, data);
-    });
-    const filesWithErrors = [];
-    filePathToData.forEach((data, filePath) => {
-        const lintErrors = [];
-        data.forEach((allMessages, line) => {
-            const ruleIds = Array.from(new Set(allMessages.sort()));
-            lintErrors.push({
-                line,
-                message: ruleIds.join(', '),
-            });
-        });
-        if (lintErrors.length === 0) {
-            return;
-        }
-        lintErrors.sort((a, b) => {
-            if (a.line < b.line) {
-                return 1;
-            }
-            if (b.line < a.line) {
-                return -1;
+                lineToRules.set(line, [ruleId]);
             }
-            return 0;
         });
-        filesWithErrors.push({
-            filePath,
-            lintErrors,
+        lineToRules.forEach((rules, line) => {
+            const message = Array.from(new Set(rules.sort())).join(', ');
+            data.set(line, message);
         });
+        filePathToData.set(filePath, data);
     });
-    return filesWithErrors;
+    return filePathToData;
+}
+export function parseOutputFile(file, projectRoot) {
+    const filePathToData = normalize(file, projectRoot);
+    return getFilesWithErrors(filePathToData);
 }

package/dist/src/utils/linters/shared/index.js

@@ -0,0 +1,29 @@
+export function getFilesWithErrors(filePathToData) {
+    const filesWithErrors = [];
+    filePathToData.forEach((data, filePath) => {
+        const lintErrors = [];
+        data.forEach((message, line) => {
+            lintErrors.push({
+                line,
+                message,
+            });
+        });
+        if (lintErrors.length === 0) {
+            return;
+        }
+        lintErrors.sort((a, b) => {
+            if (a.line < b.line) {
+                return 1;
+            }
+            if (b.line < a.line) {
+                return -1;
+            }
+            return 0;
+        });
+        filesWithErrors.push({
+            filePath,
+            lintErrors,
+        });
+    });
+    return filesWithErrors;
+}

package/dist/src/utils/linters/stylelint.js

@@ -1,6 +1,7 @@
 import { relative, sep } from 'node:path';
+import { getFilesWithErrors } from './shared/index.js';
 export const outputFilePath = '.ignore-lint-errors/stylelint.txt';
-export function parseOutputFile(file, projectRoot) {
+function normalize(file, projectRoot) {
     const filePathToData = new Map();
     const records = JSON.parse(file);
     records.forEach((record) => {
@@ -8,44 +9,26 @@ export function parseOutputFile(file, projectRoot) {
         if (!errored) {
             return;
         }
+        const filePath = relative(projectRoot, absoluteFilePath).replaceAll(sep, '/');
+        const lineToRules = new Map();
         const data = new Map();
         warnings.forEach(({ line, rule }) => {
-            if (data.has(line)) {
-                data.get(line).push(rule);
+            if (lineToRules.has(line)) {
+                lineToRules.get(line).push(rule);
             }
             else {
-                data.set(line, [rule]);
-            }
-        });
-        const filePath = relative(projectRoot, absoluteFilePath).replaceAll(sep, '/');
-        filePathToData.set(filePath, data);
-    });
-    const filesWithErrors = [];
-    filePathToData.forEach((data, filePath) => {
-        const lintErrors = [];
-        data.forEach((allMessages, line) => {
-            const ruleIds = Array.from(new Set(allMessages.sort()));
-            lintErrors.push({
-                line,
-                message: ruleIds.join(', '),
-            });
-        });
-        if (lintErrors.length === 0) {
-            return;
-        }
-        lintErrors.sort((a, b) => {
-            if (a.line < b.line) {
-                return 1;
-            }
-            if (b.line < a.line) {
-                return -1;
+                lineToRules.set(line, [rule]);
             }
-            return 0;
         });
-        filesWithErrors.push({
-            filePath,
-            lintErrors,
+        lineToRules.forEach((rules, line) => {
+            const message = Array.from(new Set(rules.sort())).join(', ');
+            data.set(line, message);
         });
+        filePathToData.set(filePath, data);
     });
-    return filesWithErrors;
+    return filePathToData;
+}
+export function parseOutputFile(file, projectRoot) {
+    const filePathToData = normalize(file, projectRoot);
+    return getFilesWithErrors(filePathToData);
 }

package/dist/src/utils/linters/typescript.js

@@ -1,6 +1,7 @@
 import { EOL } from 'node:os';
+import { getFilesWithErrors } from './shared/index.js';
 export const outputFilePath = '.ignore-lint-errors/typescript.txt';
-export function parseOutputFile(file) {
+function normalize(file) {
     const filePathToData = new Map();
     file.split(EOL).forEach((str) => {
         const matches = str.match(/^(.+)\((\d+),\d+\): error TS\d+: (.+)\.$/);
@@ -9,44 +10,17 @@ export function parseOutputFile(file) {
         }
         const filePath = matches[1];
         const line = Number.parseInt(matches[2]);
-        const message = matches[3];
+        const message = 'Incorrect type';
         if (filePathToData.has(filePath)) {
-            if (filePathToData.get(filePath).has(line)) {
-                filePathToData.get(filePath).get(line).push(message);
-            }
-            else {
-                filePathToData.get(filePath).set(line, [message]);
-            }
+            filePathToData.get(filePath).set(line, message);
         }
         else {
-            filePathToData.set(filePath, new Map([[line, [message]]]));
-        }
-    });
-    const filesWithErrors = [];
-    filePathToData.forEach((data, filePath) => {
-        const lintErrors = [];
-        data.forEach((_allMessages, line) => {
-            lintErrors.push({
-                line,
-                message: 'Incorrect type',
-            });
-        });
-        if (lintErrors.length === 0) {
-            return;
+            filePathToData.set(filePath, new Map([[line, message]]));
         }
-        lintErrors.sort((a, b) => {
-            if (a.line < b.line) {
-                return 1;
-            }
-            if (b.line < a.line) {
-                return -1;
-            }
-            return 0;
-        });
-        filesWithErrors.push({
-            filePath,
-            lintErrors,
-        });
     });
-    return filesWithErrors;
+    return filePathToData;
+}
+export function parseOutputFile(file) {
+    const filePathToData = normalize(file);
+    return getFilesWithErrors(filePathToData);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ignore-lint-errors",
-  "version": "0.5.0",
+  "version": "0.7.0",
   "description": "Codemod to ignore lint errors per line",
   "keywords": [
     "codemod",