ember-eslint-parser 0.5.9 → 0.5.11

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ember-eslint-parser",
-  "version": "0.5.9",
+  "version": "0.5.11",
   "description": "",
   "keywords": [],
   "repository": {
@@ -19,7 +19,8 @@
   ],
   "dependencies": {
     "@babel/eslint-parser": "^7.23.10",
-    "@glimmer/syntax": "^0.92.0",
+    "@glimmer/syntax": ">= 0.92.0",
+    "@typescript-eslint/tsconfig-utils": "^8.38.0",
     "content-tag": "^2.0.1",
     "eslint-scope": "^7.2.2",
     "html-tags": "^3.3.1",
@@ -43,7 +44,7 @@
     "fs-extra": "^11.2.0",
     "prettier": "^3.2.5",
     "publint": "^0.2.6",
-    "release-plan": "^0.9.0",
+    "release-plan": "^0.16.0",
     "typescript": "^5.3.3",
     "vite": "^5.0.12",
     "vitest": "^1.2.2"

package/src/parser/gjs-gts-parser.js

@@ -1,3 +1,4 @@
+const tsconfigUtils = require('@typescript-eslint/tsconfig-utils');
 const babelParser = require('@babel/eslint-parser');
 const { registerParsedFile } = require('../preprocessor/noop');
 const {
@@ -15,8 +16,119 @@ const { transformForLint, preprocessGlimmerTemplates, convertAst } = require('./
  * 3. preprocesses the templates info and prepares the Glimmer AST
  * 4. converts the js/ts AST so that it includes the Glimmer AST at the right locations, replacing the original
  */
+
+/**
+ * @param {string} tsconfigPath
+ * @param {string} rootDir
+ * @returns {boolean|undefined}
+ */
+function parseAllowJsFromTsconfig(tsconfigPath, rootDir) {
+  try {
+    const parserPath = require.resolve('@typescript-eslint/parser');
+    // eslint-disable-next-line n/no-unpublished-require
+    const tsPath = require.resolve('typescript', { paths: [parserPath] });
+    const ts = require(tsPath);
+    const parsed = tsconfigUtils.getParsedConfigFile(ts, tsconfigPath, rootDir);
+    return parsed?.options?.allowJs;
+  } catch (e) {
+    // eslint-disable-next-line no-console
+    console.warn('[ember-eslint-parser] Failed to parse tsconfig:', tsconfigPath, e);
+    return undefined;
+  }
+}
+
+/**
+ * @param {Array<boolean|undefined>} values
+ * @param {string} source
+ * @returns {boolean|null}
+ */
+function resolveAllowJs(values, source) {
+  const filtered = values.filter((val) => typeof val !== 'undefined');
+  if (filtered.length > 0) {
+    const uniqueValues = [...new Set(filtered)];
+    if (uniqueValues.length > 1) {
+      // eslint-disable-next-line no-console
+      console.warn(
+        `[ember-eslint-parser] Conflicting allowJs values in ${source}. Defaulting allowGjs to false.`
+      );
+      return false;
+    } else {
+      return uniqueValues[0];
+    }
+  }
+  return null;
+}
+
+/**
+ * @param {Array<{getCompilerOptions?: Function}>|undefined} programs
+ * @returns {boolean|null}
+ */
+function getAllowJsFromPrograms(programs) {
+  if (!Array.isArray(programs) || programs.length === 0) return null;
+  const allowJsValues = programs
+    .map((p) => p.getCompilerOptions?.())
+    .filter(Boolean)
+    .map((opts) => opts.allowJs);
+  return resolveAllowJs(allowJsValues, 'programs');
+}
+
+/**
+ * @param {boolean|object|undefined} projectService
+ * @returns {string|null}
+ */
+function getProjectServiceTsconfigPath(projectService) {
+  if (!projectService) return null;
+
+  // If projectService is true, use default behavior (nearest tsconfig.json, allowJs from config)
+  if (projectService === true) {
+    return 'tsconfig.json';
+  }
+
+  // If projectService is an object, handle ProjectServiceOptions
+  if (typeof projectService === 'object') {
+    if (typeof projectService.allowDefaultProject !== 'undefined') {
+      // eslint-disable-next-line no-console
+      console.warn(
+        '[ember-eslint-parser] projectService.allowDefaultProject is specified. Behavior may differ depending on default project config.'
+      );
+    }
+    return projectService.defaultProject ?? 'tsconfig.json';
+  }
+
+  return null;
+}
+
+/**
+ * Returns the resolved allowJs value based on priority: programs > projectService > project/tsconfig
+ */
+function getAllowJs(options) {
+  const allowJsFromPrograms = getAllowJsFromPrograms(options.programs);
+  if (allowJsFromPrograms !== null) return allowJsFromPrograms;
+
+  const rootDir = options.tsconfigRootDir || process.cwd();
+
+  const projectServiceTsconfigPath = getProjectServiceTsconfigPath(options.projectService);
+  if (projectServiceTsconfigPath) {
+    return parseAllowJsFromTsconfig(projectServiceTsconfigPath, rootDir);
+  }
+
+  let tsconfigPaths = [];
+  if (Array.isArray(options.project)) {
+    tsconfigPaths = options.project;
+  } else if (typeof options.project === 'string') {
+    tsconfigPaths = [options.project];
+  } else if (options.project) {
+    tsconfigPaths = ['tsconfig.json'];
+  }
+  if (tsconfigPaths.length > 0) {
+    const allowJsValues = tsconfigPaths.map((cfg) => parseAllowJsFromTsconfig(cfg, rootDir));
+    return resolveAllowJs(allowJsValues, 'project');
+  }
+
+  return false;
+}
+
 /**
- *
  * @type {import('eslint').ParserModule}
  */
 module.exports = {
@@ -26,7 +138,13 @@ module.exports = {
   },
 
   parseForESLint(code, options) {
-    patchTs();
+    const allowGjsWasSet = options.allowGjs !== undefined;
+    const allowGjs = allowGjsWasSet ? options.allowGjs : getAllowJs(options);
+    let actualAllowGjs;
+    // Only patch TypeScript if we actually need it.
+    if (options.programs || options.projectService || options.project) {
+      ({ allowGjs: actualAllowGjs } = patchTs({ allowGjs }));
+    }
     registerParsedFile(options.filePath);
     let jsCode = code;
     const info = transformForLint(code, options.filePath);
@@ -73,7 +191,21 @@ module.exports = {
       result.isTypescript = isTypescript || useTypescript;
       convertAst(result, preprocessedResult, visitorKeys);
       if (result.services?.program) {
-        syncMtsGtsSourceFiles(result.services?.program);
+        // Compare allowJs with the actual program's compiler options
+        const programAllowJs = result.services.program.getCompilerOptions?.()?.allowJs;
+        if (
+          !allowGjsWasSet &&
+          programAllowJs !== undefined &&
+          actualAllowGjs !== undefined &&
+          actualAllowGjs !== programAllowJs
+        ) {
+          // eslint-disable-next-line no-console
+          console.warn(
+            '[ember-eslint-parser] allowJs does not match the actual program. Consider setting allowGjs explicitly.\n' +
+              `    Current: ${allowGjs}, Program: ${programAllowJs}`
+          );
+        }
+        syncMtsGtsSourceFiles(result.services.program);
       }
       return { ...result, visitorKeys };
     } catch (e) {

package/src/parser/ts-patch.js

@@ -2,7 +2,7 @@ const fs = require('node:fs');
 const { transformForLint } = require('./transforms');
 const { replaceRange } = require('./transforms');
 
-let patchTs, replaceExtensions, syncMtsGtsSourceFiles, typescriptParser, isPatched;
+let patchTs, replaceExtensions, syncMtsGtsSourceFiles, typescriptParser, isPatched, allowGjs;
 
 try {
   const parserPath = require.resolve('@typescript-eslint/parser');
@@ -10,23 +10,27 @@ try {
   const tsPath = require.resolve('typescript', { paths: [parserPath] });
   const ts = require(tsPath);
   typescriptParser = require('@typescript-eslint/parser');
-  patchTs = function patchTs() {
-    if (isPatched) {
-      return;
-    }
+  patchTs = function patchTs(options = {}) {
+    if (isPatched) return { allowGjs };
     isPatched = true;
+    allowGjs = options.allowGjs !== undefined ? options.allowGjs : true;
     const sys = { ...ts.sys };
     const newSys = {
       ...ts.sys,
       readDirectory(...args) {
         const results = sys.readDirectory.call(this, ...args);
-        return [
-          ...results,
-          ...results.filter((x) => x.endsWith('.gts')).map((f) => f.replace(/\.gts$/, '.mts')),
-        ];
+        const gtsVirtuals = results
+          .filter((x) => x.endsWith('.gts'))
+          .map((f) => f.replace(/\.gts$/, '.mts'));
+        const gjsVirtuals = allowGjs
+          ? results.filter((x) => x.endsWith('.gjs')).map((f) => f.replace(/\.gjs$/, '.mjs'))
+          : [];
+        return results.concat(gtsVirtuals, gjsVirtuals);
       },
       fileExists(fileName) {
-        return fs.existsSync(fileName.replace(/\.m?ts$/, '.gts')) || fs.existsSync(fileName);
+        const gtsExists = fs.existsSync(fileName.replace(/\.m?ts$/, '.gts'));
+        const gjsExists = allowGjs ? fs.existsSync(fileName.replace(/\.m?js$/, '.gjs')) : false;
+        return gtsExists || gjsExists || fs.existsSync(fileName);
       },
       readFile(fname) {
         let fileName = fname;
@@ -38,25 +42,30 @@ try {
         try {
           content = fs.readFileSync(fileName).toString();
         } catch {
-          fileName = fileName.replace(/\.m?ts$/, '.gts');
+          if (fileName.match(/\.m?ts$/)) {
+            fileName = fileName.replace(/\.m?ts$/, '.gts');
+          } else if (allowGjs && fileName.match(/\.m?js$/)) {
+            fileName = fileName.replace(/\.m?js$/, '.gjs');
+          }
           content = fs.readFileSync(fileName).toString();
         }
-        if (fileName.endsWith('.gts')) {
+        if (fileName.endsWith('.gts') || (allowGjs && fileName.endsWith('.gjs'))) {
           try {
             content = transformForLint(content).output;
           } catch (e) {
-            console.error('failed to transformForLint for gts processing');
+            console.error('failed to transformForLint for gts/gjs processing');
             console.error(e);
           }
         }
         if (
           (!fileName.endsWith('.d.ts') && fileName.endsWith('.ts')) ||
-          fileName.endsWith('.gts')
+          fileName.endsWith('.gts') ||
+          (allowGjs && fileName.endsWith('.gjs'))
         ) {
           try {
             content = replaceExtensions(content);
           } catch (e) {
-            console.error('failed to replace extensions for gts processing');
+            console.error('failed to replace extensions for gts/gjs processing');
             console.error(e);
           }
         }
@@ -64,6 +73,7 @@ try {
       },
     };
     ts.setSys(newSys);
+    return { allowGjs };
   };
 
   replaceExtensions = function replaceExtensions(code) {
@@ -88,35 +98,42 @@ try {
    */
   syncMtsGtsSourceFiles = function syncMtsGtsSourceFiles(program) {
     const sourceFiles = program.getSourceFiles();
-    for (const sourceFile of sourceFiles) {
-      // check for deleted gts files, need to remove mts as well
-      if (sourceFile.path.match(/\.m?ts$/) && sourceFile.isVirtualGts) {
-        const gtsFile = program.getSourceFile(sourceFile.path.replace(/\.m?ts$/, '.gts'));
-        if (!gtsFile) {
+    function syncVirtualFile(sourceFile, ext, virtualExt, virtualFlag) {
+      // check for deleted files, need to remove virtual as well
+      if (sourceFile.path.match(new RegExp(`\\.m?${virtualExt}$`)) && sourceFile[virtualFlag]) {
+        const origFile = program.getSourceFile(
+          sourceFile.path.replace(new RegExp(`\\.m?${virtualExt}$`), `.${ext}`)
+        );
+        if (!origFile) {
           sourceFile.version = null;
         }
       }
-      if (sourceFile.path.endsWith('.gts')) {
-        /**
-         * @type {ts.SourceFile}
-         */
-        let mtsSourceFile = program.getSourceFile(sourceFile.path.replace(/\.gts$/, '.mts'));
-        if (!mtsSourceFile) {
-          mtsSourceFile = program.getSourceFile(sourceFile.path.replace(/\.gts$/, '.ts'));
+      if (sourceFile.path.endsWith(`.${ext}`)) {
+        let virtualSourceFile = program.getSourceFile(
+          sourceFile.path.replace(new RegExp(`\\.${ext}$`), `.${virtualExt}`)
+        );
+        if (!virtualSourceFile) {
+          virtualSourceFile = program.getSourceFile(
+            sourceFile.path.replace(new RegExp(`\\.${ext}$`), virtualExt === 'mts' ? '.ts' : '.js')
+          );
         }
-        if (mtsSourceFile) {
+        if (virtualSourceFile) {
           const keep = {
-            fileName: mtsSourceFile.fileName,
-            path: mtsSourceFile.path,
-            originalFileName: mtsSourceFile.originalFileName,
-            resolvedPath: mtsSourceFile.resolvedPath,
-            impliedNodeFormat: mtsSourceFile.impliedNodeFormat,
+            fileName: virtualSourceFile.fileName,
+            path: virtualSourceFile.path,
+            originalFileName: virtualSourceFile.originalFileName,
+            resolvedPath: virtualSourceFile.resolvedPath,
+            impliedNodeFormat: virtualSourceFile.impliedNodeFormat,
           };
-          Object.assign(mtsSourceFile, sourceFile, keep);
-          mtsSourceFile.isVirtualGts = true;
+          Object.assign(virtualSourceFile, sourceFile, keep);
+          virtualSourceFile[virtualFlag] = true;
         }
       }
     }
+    for (const sourceFile of sourceFiles) {
+      syncVirtualFile(sourceFile, 'gts', 'mts', 'isVirtualGts');
+      syncVirtualFile(sourceFile, 'gjs', 'mjs', 'isVirtualGjs');
+    }
   };
 } catch /* istanbul ignore next */ {
   // typescript not available