@ithinkdt/lint 4.0.0-2 → 4.0.0-201

package/src/{typescript-eslint-parser-for-extra-files → tsparser-for-extra-files}/ts.js

@@ -1,9 +1,13 @@
 import path from 'node:path'
+
 import ts from 'typescript'
+
 import { transformExtraFile } from './transform.js'
 
 export class TSServiceManager {
-    tsServices = new Map()
+    constructor() {
+        this.tsServices = new Map()
+    }
 
     getProgram(code, options) {
         const tsconfigPath = options.project
@@ -15,8 +19,8 @@ export class TSServiceManager {
             this.tsServices.set(tsconfigPath, serviceList)
         }
 
-        let service = serviceList.find((service) =>
-            extraFileExtensions.every((ext) => service.extraFileExtensions.includes(ext)),
+        let service = serviceList.find(service =>
+            extraFileExtensions.every(ext => service.extraFileExtensions.includes(ext)),
         )
         if (!service) {
             service = new TSService(tsconfigPath, extraFileExtensions)
@@ -28,58 +32,18 @@ export class TSServiceManager {
 }
 
 export class TSService {
-    watch
-
-    patchedHostSet = new WeakSet()
-
-    tsconfigPath
-
-    extraFileExtensions
-
-    currTarget = {
-        code: '',
-        filePath: '',
-        dirMap: new Map(),
-    }
-
-    fileWatchCallbacks = new Map()
-
     constructor(tsconfigPath, extraFileExtensions) {
+        this.patchedHostSet = new WeakSet()
         this.tsconfigPath = tsconfigPath
         this.extraFileExtensions = extraFileExtensions
-        this.watch = this.createWatch(tsconfigPath, extraFileExtensions)
-    }
-
-    getProgram(code, filePath) {
-        const normalized = normalizeFileName(filePath)
-        const lastTarget = this.currTarget
-
-        const dirMap = new Map()
-        let childPath = normalized
-        for (const dirName of iterateDirs(normalized)) {
-            dirMap.set(dirName, { path: childPath, name: path.basename(childPath) })
-            childPath = dirName
-        }
         this.currTarget = {
-            code,
-            filePath: normalized,
-            dirMap,
+            code: '',
+            filePath: '',
+            sourceFile: undefined,
+            dirMap: new Map(),
         }
-        for (const { filePath: targetPath } of [this.currTarget, lastTarget]) {
-            if (!targetPath) continue
-            if (!ts.sys.fileExists(targetPath)) {
-                // Signal a directory change to request a re-scan of the directory
-                // because it targets a file that does not actually exist.
-                this.fileWatchCallbacks.get(normalizeFileName(this.tsconfigPath))?.update()
-            }
-            this.fileWatchCallbacks.get(normalizeFileName(targetPath))?.update()
-        }
-
-        const program = this.watch.getProgram().getProgram()
-        // sets parent pointers in source files
-        program.getTypeChecker()
-
-        return program
+        this.fileWatchCallbacks = new Map()
+        this.watch = this.createWatch(tsconfigPath, extraFileExtensions)
     }
 
     createWatch(tsconfigPath, extraFileExtensions) {
@@ -92,28 +56,28 @@ export class TSService {
 
                 const getTargetSourceFile = (fileName, languageVersionOrOptions) => {
                     if (
-                        this.currTarget.filePath === normalizeFileName(fileName) &&
-                        isExtra(fileName, extraFileExtensions)
+                        this.currTarget.filePath === normalizeFileName(fileName)
+                        && isExtra(fileName, extraFileExtensions)
                     ) {
-                        // Parse the target file as TSX.
-                        return (this.currTarget.sourceFile ??= ts.createSourceFile(
-                            this.currTarget.filePath,
-                            this.currTarget.code,
-                            languageVersionOrOptions,
-                            true,
-                            ts.ScriptKind.TSX,
-                        ))
+                        return (
+                            this.currTarget.sourceFile
+                            ?? ts.createSourceFile(
+                                this.currTarget.filePath,
+                                this.currTarget.code,
+                                languageVersionOrOptions,
+                                true,
+                                ts.ScriptKind.TSX,
+                            )
+                        )
                     }
-                    return
+                    return null
                 }
 
                 const original = {
                     getSourceFile: host.getSourceFile,
                     getSourceFileByPath: host.getSourceFileByPath,
                 }
-
                 host.getSourceFile = (fileName, languageVersionOrOptions, ...args) => {
-                    // Always call the original function, because it calls the file watcher.
                     const originalSourceFile = original.getSourceFile.call(
                         host,
                         fileName,
@@ -123,7 +87,6 @@ export class TSService {
                     return getTargetSourceFile(fileName, languageVersionOrOptions) ?? originalSourceFile
                 }
                 host.getSourceFileByPath = (fileName, path, languageVersionOrOptions, ...args) => {
-                    // Always call the original function, because it calls the file watcher.
                     const originalSourceFile = original.getSourceFileByPath.call(
                         host,
                         fileName,
@@ -149,10 +112,6 @@ export class TSService {
             {
                 noEmit: true,
                 jsx: ts.JsxEmit.Preserve,
-
-                // This option is required if `includes` only includes `*.vue` files.
-                // However, the option is not in the documentation.
-                // https://github.com/microsoft/TypeScript/issues/28447
                 allowNonTsExtensions: true,
             },
             ts.sys,
@@ -160,11 +119,9 @@ export class TSService {
             (diagnostic) => {
                 throw new Error(formatDiagnostics([diagnostic]))
             },
-            () => {
-                // Not reported in reportWatchStatus.
-            },
+            () => {},
             undefined,
-            extraFileExtensions.map((extension) => ({
+            extraFileExtensions.map(extension => ({
                 extension,
                 isMixedContent: true,
                 scriptKind: ts.ScriptKind.Deferred,
@@ -180,28 +137,25 @@ export class TSService {
         watchCompilerHost.getDirectories = (dirName, ...args) => {
             const result = distinctArray(
                 ...original.getDirectories.call(watchCompilerHost, dirName, ...args),
-                // Include the path to the target file if the target file does not actually exist.
                 this.currTarget.dirMap.get(normalizeFileName(dirName))?.name,
             )
             return result
         }
         watchCompilerHost.directoryExists = (dirName, ...args) => {
             return (
-                original.directoryExists.call(watchCompilerHost, dirName, ...args) ||
-                // Include the path to the target file if the target file does not actually exist.
-                this.currTarget.dirMap.has(normalizeFileName(dirName))
+                original.directoryExists.call(watchCompilerHost, dirName, ...args)
+                || this.currTarget.dirMap.has(normalizeFileName(dirName))
             )
         }
         watchCompilerHost.readDirectory = (dirName, ...args) => {
             let results = original.readDirectory.call(watchCompilerHost, dirName, ...args)
 
-            // Include the target file if the target file does not actually exist.
             const file = this.currTarget.dirMap.get(normalizeFileName(dirName))
             if (file) {
                 if (file.path === this.currTarget.filePath) {
                     results.push(file.path)
                 } else {
-                    results = results.filter((f) => file.path !== f && file.name !== f)
+                    results = results.filter(f => file.path !== f && file.name !== f)
                 }
             }
 
@@ -209,11 +163,10 @@ export class TSService {
         }
         watchCompilerHost.readFile = (fileName, ...args) => {
             const realFileName = getRealFileNameIfExist(fileName)
-            if (realFileName == undefined) {
+            if (realFileName == null) {
                 return
             }
             if (this.currTarget.filePath === realFileName) {
-                // It is the file currently being parsed.
                 return transformExtraFile(this.currTarget.code, {
                     filePath: realFileName,
                     current: true,
@@ -229,20 +182,16 @@ export class TSService {
                 current: false,
             })
         }
-        // Modify it so that it can be determined that the virtual file actually exists.
         watchCompilerHost.fileExists = (fileName) => {
-            return getRealFileNameIfExist(fileName) != undefined
+            return getRealFileNameIfExist(fileName) != null
         }
 
         const getRealFileNameIfExist = (fileName) => {
             const normalizedFileName = normalizeFileName(fileName)
-            // Even if it is actually a file, if it is specified as a directory to the target file,
-            // it is assumed that it does not exist as a file.
             if (this.currTarget.dirMap.has(normalizedFileName)) {
-                return
+                return null
             }
             if (this.currTarget.filePath === normalizedFileName) {
-                // It is the file currently being parsed.
                 return normalizedFileName
             }
             const exists = original.fileExists.call(watchCompilerHost, normalizedFileName)
@@ -253,18 +202,16 @@ export class TSService {
                 const real = normalizedFileName.slice(0, -4)
                 for (const dts of toExtraDtsFileNames(real, extraFileExtensions)) {
                     if (original.fileExists.call(watchCompilerHost, dts)) {
-                        // If the d.ts file exists, respect it and consider the virtual file not to exist.
-                        return
+                        return null
                     }
                 }
                 if (original.fileExists.call(watchCompilerHost, real)) {
                     return real
                 }
             }
-            return
+            return null
         }
 
-        // It keeps a callback to mark the parsed file as changed so that it can be re-parsed.
         watchCompilerHost.watchFile = (fileName, callback) => {
             const normalized = normalizeFileName(fileName)
             this.fileWatchCallbacks.set(normalized, {
@@ -277,23 +224,16 @@ export class TSService {
                 },
             }
         }
-        // Use watchCompilerHost but don't actually watch the files and directories.
         watchCompilerHost.watchDirectory = () => {
             return {
-                close: () => {
-                    // noop
-                },
+                close: () => {},
             }
         }
 
-        /**
-         * It heavily references typescript-eslint.
-         * @see https://github.com/typescript-eslint/typescript-eslint/blob/84e316be33dac5302bd0367c4d1960bef40c484d/packages/typescript-estree/src/create-program/createWatchProgram.ts#L297-L309
-         */
         watchCompilerHost.afterProgramCreate = (program) => {
             const originalDiagnostics = program.getConfigFileParsingDiagnostics()
             const configFileDiagnostics = originalDiagnostics.filter(
-                (diag) => diag.category === ts.DiagnosticCategory.Error && diag.code !== 18_003,
+                diag => diag.category === ts.DiagnosticCategory.Error && diag.code !== 18_003,
             )
             if (configFileDiagnostics.length > 0) {
                 throw new Error(formatDiagnostics(configFileDiagnostics))
@@ -303,33 +243,60 @@ export class TSService {
         const watch = ts.createWatchProgram(watchCompilerHost)
         return watch
     }
+
+    getProgram(code, filePath) {
+        const normalized = normalizeFileName(filePath)
+        const lastTarget = this.currTarget
+
+        const dirMap = new Map()
+        let childPath = normalized
+        for (const dirName of iterateDirs(normalized)) {
+            dirMap.set(dirName, { path: childPath, name: path.basename(childPath) })
+            childPath = dirName
+        }
+        this.currTarget = {
+            code,
+            filePath: normalized,
+            dirMap,
+        }
+        for (const { filePath: targetPath } of [this.currTarget, lastTarget]) {
+            if (!targetPath) continue
+            if (!ts.sys.fileExists(targetPath)) {
+                this.fileWatchCallbacks.get(normalizeFileName(this.tsconfigPath))?.update()
+            }
+            this.fileWatchCallbacks.get(normalizeFileName(targetPath))?.update()
+        }
+
+        const program = this.watch.getProgram().getProgram()
+        program.getTypeChecker()
+
+        return program
+    }
+
+    watch = null
 }
 
-/** If the given filename has extra extensions, returns the d.ts filename. */
 function toExtraDtsFileNames(fileName, extraFileExtensions) {
     const ext = getExtIfExtra(fileName, extraFileExtensions)
-    if (ext != undefined) {
+    if (ext != null) {
         return [`${fileName}.d.ts`, `${fileName.slice(0, -ext.length)}.d${ext}.ts`]
     }
     return []
 }
 
-/** Checks the given filename has extra extension or not. */
 function isExtra(fileName, extraFileExtensions) {
-    return getExtIfExtra(fileName, extraFileExtensions) != undefined
+    return getExtIfExtra(fileName, extraFileExtensions) != null
 }
 
-/** Gets the file extension if the given file is an extra extension file. */
 function getExtIfExtra(fileName, extraFileExtensions) {
     for (const extraFileExtension of extraFileExtensions) {
         if (fileName.endsWith(extraFileExtension)) {
             return extraFileExtension
         }
     }
-    return
+    return null
 }
 
-/** Checks the given filename is virtual file tsx or not. */
 function isVirtualTSX(fileName, extraFileExtensions) {
     for (const extraFileExtension of extraFileExtensions) {
         if (fileName.endsWith(`${extraFileExtension}.tsx`)) {
@@ -341,7 +308,7 @@ function isVirtualTSX(fileName, extraFileExtensions) {
 
 function formatDiagnostics(diagnostics) {
     return ts.formatDiagnostics(diagnostics, {
-        getCanonicalFileName: (f) => f,
+        getCanonicalFileName: f => f,
         getCurrentDirectory: () => process.cwd(),
         getNewLine: () => '\n',
     })
@@ -353,9 +320,9 @@ function normalizeFileName(fileName) {
         normalized = normalized.slice(0, -1)
     }
     if (ts.sys.useCaseSensitiveFileNames) {
-        return toAbsolutePath(normalized)
+        return toAbsolutePath(normalized, null)
     }
-    return toAbsolutePath(normalized.toLowerCase())
+    return toAbsolutePath(normalized.toLowerCase(), null)
 }
 
 function toAbsolutePath(filePath, baseDir) {
@@ -372,7 +339,7 @@ function* iterateDirs(filePath) {
 }
 
 function distinctArray(...list) {
-    return [...new Set(ts.sys.useCaseSensitiveFileNames ? list : list.map((s) => s?.toLowerCase()))].filter(
-        (s) => s != undefined,
+    return [...new Set(ts.sys.useCaseSensitiveFileNames ? list : list.map(s => s?.toLowerCase()))].filter(
+        s => s != null,
     )
 }

package/src/{typescript-eslint-parser-for-extra-files → tsparser-for-extra-files}/utils/resolve-project-list.js

@@ -1,7 +1,9 @@
 import path from 'node:path'
-import ts from 'typescript'
+
 import { globbySync } from 'globby'
 import isGlob from 'is-glob'
+import ts from 'typescript'
+
 /**
  * Normalizes, sanitizes, resolves and filters the provided project paths
  */
@@ -9,7 +11,7 @@ export function resolveProjectList(options) {
     const sanitizedProjects = []
 
     // Normalize and sanitize the project paths
-    if (options.project) {
+    if (options.project != null) {
         for (const project of options.project) {
             if (typeof project === 'string') {
                 sanitizedProjects.push(project)
@@ -22,15 +24,18 @@ export function resolveProjectList(options) {
     }
 
     const projectFolderIgnoreList = []
+
     for (const folder of options.projectFolderIgnoreList ?? ['**/node_modules/**']) {
         if (typeof folder === 'string') {
-            projectFolderIgnoreList.push(folder.startsWith('!') ? folder : `!${folder}`)
+            projectFolderIgnoreList.push(folder)
         }
     }
+    // prefix with a ! for not match glob
+    projectFolderIgnoreList.map(folder => (folder.startsWith('!') ? folder : `!${folder}`))
 
     // Transform glob patterns into paths
-    const nonGlobProjects = sanitizedProjects.filter((project) => !isGlob(project))
-    const globProjects = sanitizedProjects.filter((project) => isGlob(project))
+    const nonGlobProjects = sanitizedProjects.filter(project => !isGlob(project))
+    const globProjects = sanitizedProjects.filter(project => isGlob(project))
 
     const uniqueCanonicalProjectPaths = new Set(
         [
@@ -38,9 +43,9 @@ export function resolveProjectList(options) {
             ...(globProjects.length === 0
                 ? []
                 : globbySync([...globProjects, ...projectFolderIgnoreList], {
-                      cwd: options.tsconfigRootDir,
-                  })),
-        ].map((project) => getCanonicalFileName(ensureAbsolutePath(project, options.tsconfigRootDir))),
+                        cwd: options.tsconfigRootDir,
+                    })),
+        ].map(project => _getCanonicalFileName(_ensureAbsolutePath(project, options.tsconfigRootDir))),
     )
 
     return [...uniqueCanonicalProjectPaths]
@@ -48,9 +53,9 @@ export function resolveProjectList(options) {
 
 // typescript doesn't provide a ts.sys implementation for browser environments
 const useCaseSensitiveFileNames = ts.sys === undefined ? true : ts.sys.useCaseSensitiveFileNames
-const correctPathCasing = useCaseSensitiveFileNames ? (filePath) => filePath : (filePath) => filePath.toLowerCase()
+const correctPathCasing = useCaseSensitiveFileNames ? filePath => filePath : filePath => filePath.toLowerCase()
 
-function getCanonicalFileName(filePath) {
+function _getCanonicalFileName(filePath) {
     let normalized = path.normalize(filePath)
     if (normalized.endsWith(path.sep)) {
         normalized = normalized.slice(0, -1)
@@ -58,6 +63,6 @@ function getCanonicalFileName(filePath) {
     return correctPathCasing(normalized)
 }
 
-function ensureAbsolutePath(p, tsconfigRootDir) {
+function _ensureAbsolutePath(p, tsconfigRootDir) {
     return path.isAbsolute(p) ? p : path.join(tsconfigRootDir || process.cwd(), p)
 }