ignore-lint-errors 0.2.0 → 0.4.0

package/dist/bin/ignore-lint-errors.js

@@ -8,7 +8,7 @@ process.title = 'ignore-lint-errors';
 // Set codemod options
 const argv = yargs(hideBin(process.argv))
     .option('linter', {
-    choices: ['eslint', 'typescript'],
+    choices: ['eslint', 'stylelint', 'typescript'],
     describe: 'Linter to run',
     type: 'string',
 })

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

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

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

@@ -1,20 +1,16 @@
 import { readFileSync, writeFileSync } from 'node:fs';
-import { EOL } from 'node:os';
 import { join } from 'node:path';
 import { removeFiles } from '@codemod-utils/files';
+import { ignoreErrors } from '../../utils/ignore-errors/stylelint.js';
 import { outputFilePath, parseOutputFile } from '../../utils/linters/eslint.js';
 export function ignoreErrorsFromEslint(options) {
     const { projectRoot } = options;
     const outputFile = readFileSync(join(projectRoot, outputFilePath), 'utf8');
-    const filesWithErrors = parseOutputFile(outputFile);
-    filesWithErrors.forEach(({ absoluteFilePath, lintErrors }) => {
-        const file = readFileSync(absoluteFilePath, 'utf8');
-        const lines = file.split(EOL);
-        lintErrors.forEach(({ line, message }) => {
-            const ignoreDirective = `// @ts-expect-error: ${message}`;
-            lines.splice(line - 1, 0, ignoreDirective);
-        });
-        writeFileSync(absoluteFilePath, lines.join(EOL), 'utf8');
+    const filesWithErrors = parseOutputFile(outputFile, projectRoot);
+    filesWithErrors.forEach(({ filePath, lintErrors }) => {
+        const file = readFileSync(join(projectRoot, filePath), 'utf8');
+        const newFile = ignoreErrors(file, lintErrors);
+        writeFileSync(join(projectRoot, filePath), newFile, 'utf8');
     });
     removeFiles([outputFilePath], { projectRoot });
 }

package/dist/src/steps/ignore-errors/index.js

@@ -1,2 +1,3 @@
 export * from './eslint.js';
+export * from './stylelint.js';
 export * from './typescript.js';

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

@@ -0,0 +1,16 @@
+import { readFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { removeFiles } from '@codemod-utils/files';
+import { ignoreErrors } from '../../utils/ignore-errors/stylelint.js';
+import { outputFilePath, parseOutputFile, } from '../../utils/linters/stylelint.js';
+export function ignoreErrorsFromStylelint(options) {
+    const { projectRoot } = options;
+    const outputFile = readFileSync(join(projectRoot, outputFilePath), 'utf8');
+    const filesWithErrors = parseOutputFile(outputFile, projectRoot);
+    filesWithErrors.forEach(({ filePath, lintErrors }) => {
+        const file = readFileSync(join(projectRoot, filePath), 'utf8');
+        const newFile = ignoreErrors(file, lintErrors);
+        writeFileSync(join(projectRoot, filePath), newFile, 'utf8');
+    });
+    removeFiles([outputFilePath], { projectRoot });
+}

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

@@ -1,42 +1,19 @@
 import { readFileSync, writeFileSync } from 'node:fs';
-import { EOL } from 'node:os';
 import { join } from 'node:path';
-import { findTemplateTags } from '@codemod-utils/ast-template-tag';
 import { removeFiles } from '@codemod-utils/files';
+import { ignoreErrors, ignoreErrorsFallback, isParseable, } from '../../utils/ignore-errors/typescript.js';
 import { outputFilePath, parseOutputFile, } from '../../utils/linters/typescript.js';
-function findLinesWithTemplate(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 lineStart = getLOC(file.substring(0, range.startChar)) + 1;
-        const lineEnd = getLOC(file.substring(0, range.endChar)) + 1;
-        linesWithTemplate.push([lineStart, lineEnd]);
-    });
-    return linesWithTemplate;
-}
 export function ignoreErrorsFromTypescript(options) {
     const { projectRoot } = options;
     const outputFile = readFileSync(join(projectRoot, outputFilePath), 'utf8');
     const filesWithErrors = parseOutputFile(outputFile);
     filesWithErrors.forEach(({ filePath, lintErrors }) => {
         const file = readFileSync(join(projectRoot, filePath), 'utf8');
-        const lines = file.split(EOL);
-        const linesWithTemplate = findLinesWithTemplate(file);
-        lintErrors.forEach(({ line, message }) => {
-            const erroredInTemplate = linesWithTemplate.some(([lineStart, lineEnd]) => {
-                return lineStart <= line && line <= lineEnd;
-            });
-            const ignoreDirective = erroredInTemplate
-                ? `{{! @glint-expect-error: ${message} }}`
-                : `// @ts-expect-error: ${message}`;
-            lines.splice(line - 1, 0, ignoreDirective);
-        });
-        writeFileSync(join(projectRoot, filePath), lines.join(EOL), 'utf8');
+        let newFile = ignoreErrors(file, lintErrors);
+        if (!isParseable(newFile)) {
+            newFile = ignoreErrorsFallback(file, lintErrors);
+        }
+        writeFileSync(join(projectRoot, filePath), newFile, 'utf8');
     });
     removeFiles([outputFilePath], { projectRoot });
 }

package/dist/src/steps/ignore-errors.js

@@ -1,4 +1,4 @@
-import { ignoreErrorsFromEslint, ignoreErrorsFromTypescript, } from './ignore-errors/index.js';
+import { ignoreErrorsFromEslint, ignoreErrorsFromStylelint, ignoreErrorsFromTypescript, } from './ignore-errors/index.js';
 export function ignoreErrors(options) {
     const { dependencies, linter } = options;
     switch (linter) {
@@ -8,6 +8,12 @@ export function ignoreErrors(options) {
             }
             break;
         }
+        case 'stylelint': {
+            if (dependencies.stylelint) {
+                ignoreErrorsFromStylelint(options);
+            }
+            break;
+        }
         case 'typescript': {
             if (dependencies.typescript) {
                 ignoreErrorsFromTypescript(options);

package/dist/src/steps/lint-files/index.js

@@ -1,2 +1,3 @@
 export * from './eslint.js';
+export * from './stylelint.js';
 export * from './typescript.js';

package/dist/src/steps/lint-files/stylelint.js

@@ -0,0 +1,19 @@
+import { execSync } from 'node:child_process';
+import { outputFilePath } from '../../utils/linters/stylelint.js';
+export function runStylelint(options) {
+    const { projectRoot } = options;
+    const command = [
+        './node_modules/.bin/stylelint "**/*.css"',
+        '--allow-empty-input',
+        '--formatter json',
+        `--output-file ${outputFilePath}`,
+        '--quiet',
+        '2>/dev/null', // Suppress output to process.stderr
+    ].join(' ');
+    try {
+        execSync(command, { cwd: projectRoot });
+    }
+    catch {
+        // Do nothing
+    }
+}

package/dist/src/steps/lint-files.js

@@ -1,6 +1,6 @@
 import { existsSync, mkdirSync } from 'node:fs';
 import { join } from 'node:path';
-import { runEslint, runTypescript } from './lint-files/index.js';
+import { runEslint, runStylelint, runTypescript } from './lint-files/index.js';
 export function lintFiles(options) {
     const { dependencies, linter, projectRoot } = options;
     if (!existsSync(join(projectRoot, '.ignore-lint-errors'))) {
@@ -13,6 +13,12 @@ export function lintFiles(options) {
             }
             break;
         }
+        case 'stylelint': {
+            if (dependencies.stylelint) {
+                runStylelint(options);
+            }
+            break;
+        }
         case 'typescript': {
             if (dependencies.typescript) {
                 runTypescript(options);

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

@@ -0,0 +1,9 @@
+import { EOL } from 'node:os';
+export function ignoreErrors(file, lintErrors) {
+    const lines = file.split(EOL);
+    lintErrors.forEach(({ line, message }) => {
+        const ignoreDirective = `// eslint-disable-next-line ${message}`;
+        lines.splice(line - 1, 0, ignoreDirective);
+    });
+    return lines.join(EOL);
+}

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

@@ -0,0 +1,9 @@
+import { EOL } from 'node:os';
+export function ignoreErrors(file, lintErrors) {
+    const lines = file.split(EOL);
+    lintErrors.forEach(({ line, message }) => {
+        const ignoreDirective = `/* stylelint-disable-next-line ${message} */`;
+        lines.splice(line - 1, 0, ignoreDirective);
+    });
+    return lines.join(EOL);
+}

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

@@ -0,0 +1,74 @@
+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) {
+    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 lineStart = getLOC(file.substring(0, range.startChar)) + 1;
+        const lineEnd = getLOC(file.substring(0, range.endChar)) + 1;
+        linesWithTemplate.push([lineStart, lineEnd]);
+    });
+    return linesWithTemplate;
+}
+export function ignoreErrors(file, lintErrors) {
+    const linesWithTemplate = findLinesWithTemplate(file);
+    const lines = file.split(EOL);
+    lintErrors.forEach(({ line, message }) => {
+        const erroredInTemplate = linesWithTemplate.some(([lineStart, lineEnd]) => {
+            return lineStart <= line && line <= lineEnd;
+        });
+        const ignoreDirective = erroredInTemplate
+            ? `{{! @glint-expect-error: ${message} }}`
+            : `// @ts-expect-error: ${message}`;
+        lines.splice(line - 1, 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);
+    let hasErrorInTemplate = false;
+    lintErrors.forEach(({ line, message }) => {
+        const erroredInTemplate = linesWithTemplate.some(([lineStart, lineEnd]) => {
+            return lineStart <= line && line <= lineEnd;
+        });
+        if (erroredInTemplate) {
+            hasErrorInTemplate = true;
+            return;
+        }
+        const ignoreDirective = `// @ts-expect-error: ${message}`;
+        lines.splice(line - 1, 0, ignoreDirective);
+    });
+    let newFile = lines.join(EOL);
+    if (hasErrorInTemplate) {
+        newFile = updateTemplates(newFile, (code) => {
+            const ignoreDirective = '{{! @glint-nocheck }}';
+            return [ignoreDirective, code].join(EOL);
+        });
+    }
+    return newFile;
+}
+export function isParseable(file) {
+    const traverse = AST.traverse();
+    let isParseable = true;
+    function parseTemplate(template) {
+        try {
+            traverse(template);
+        }
+        catch {
+            isParseable = false;
+        }
+    }
+    const templateTags = findTemplateTags(file);
+    templateTags.forEach((templateTag) => {
+        parseTemplate(templateTag.contents);
+    });
+    return isParseable;
+}

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

@@ -1,5 +1,6 @@
+import { relative, sep } from 'node:path';
 export const outputFilePath = '.ignore-lint-errors/eslint.txt';
-export function parseOutputFile(file) {
+export function parseOutputFile(file, projectRoot) {
     const filePathToData = new Map();
     const records = JSON.parse(file);
     records.forEach((record) => {
@@ -13,10 +14,11 @@ export function parseOutputFile(file) {
                 data.set(line, [ruleId]);
             }
         });
-        filePathToData.set(absoluteFilePath, data);
+        const filePath = relative(projectRoot, absoluteFilePath).replaceAll(sep, '/');
+        filePathToData.set(filePath, data);
     });
     const filesWithErrors = [];
-    filePathToData.forEach((data, absoluteFilePath) => {
+    filePathToData.forEach((data, filePath) => {
         const lintErrors = [];
         data.forEach((allMessages, line) => {
             const ruleIds = Array.from(new Set(allMessages.sort()));
@@ -25,6 +27,9 @@ export function parseOutputFile(file) {
                 message: ruleIds.join(', '),
             });
         });
+        if (lintErrors.length === 0) {
+            return;
+        }
         lintErrors.sort((a, b) => {
             if (a.line < b.line) {
                 return 1;
@@ -35,7 +40,7 @@ export function parseOutputFile(file) {
             return 0;
         });
         filesWithErrors.push({
-            absoluteFilePath,
+            filePath,
             lintErrors,
         });
     });

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

@@ -0,0 +1,51 @@
+import { relative, sep } from 'node:path';
+export const outputFilePath = '.ignore-lint-errors/stylelint.txt';
+export function parseOutputFile(file, projectRoot) {
+    const filePathToData = new Map();
+    const records = JSON.parse(file);
+    records.forEach((record) => {
+        const { errored, source: absoluteFilePath, warnings } = record;
+        if (!errored) {
+            return;
+        }
+        const data = new Map();
+        warnings.forEach(({ line, rule }) => {
+            if (data.has(line)) {
+                data.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;
+            }
+            return 0;
+        });
+        filesWithErrors.push({
+            filePath,
+            lintErrors,
+        });
+    });
+    return filesWithErrors;
+}

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

@@ -31,6 +31,9 @@ export function parseOutputFile(file) {
                 message: 'Incorrect type',
             });
         });
+        if (lintErrors.length === 0) {
+            return;
+        }
         lintErrors.sort((a, b) => {
             if (a.line < b.line) {
                 return 1;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ignore-lint-errors",
-  "version": "0.2.0",
+  "version": "0.4.0",
   "description": "Codemod to add ignore directives",
   "keywords": [
     "codemod",
@@ -17,6 +17,7 @@
     "dist"
   ],
   "dependencies": {
+    "@codemod-utils/ast-template": "^3.0.1",
     "@codemod-utils/ast-template-tag": "^2.1.0",
     "@codemod-utils/files": "^4.0.1",
     "@codemod-utils/package-json": "^4.0.1",