@ithinkdt/lint 4.0.0-0

package/src/typescript-eslint-parser-for-extra-files/ts.js

@@ -0,0 +1,378 @@
+import path from 'node:path'
+import ts from 'typescript'
+import { transformExtraFile } from './transform.js'
+
+export class TSServiceManager {
+    tsServices = new Map()
+
+    getProgram(code, options) {
+        const tsconfigPath = options.project
+        const extraFileExtensions = [...new Set(options.extraFileExtensions)]
+
+        let serviceList = this.tsServices.get(tsconfigPath)
+        if (!serviceList) {
+            serviceList = []
+            this.tsServices.set(tsconfigPath, serviceList)
+        }
+
+        let service = serviceList.find((service) =>
+            extraFileExtensions.every((ext) => service.extraFileExtensions.includes(ext)),
+        )
+        if (!service) {
+            service = new TSService(tsconfigPath, extraFileExtensions)
+            serviceList.unshift(service)
+        }
+
+        return service.getProgram(code, options.filePath)
+    }
+}
+
+export class TSService {
+    watch
+
+    patchedHostSet = new WeakSet()
+
+    tsconfigPath
+
+    extraFileExtensions
+
+    currTarget = {
+        code: '',
+        filePath: '',
+        dirMap: new Map(),
+    }
+
+    fileWatchCallbacks = new Map()
+
+    constructor(tsconfigPath, extraFileExtensions) {
+        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,
+        }
+        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
+    }
+
+    createWatch(tsconfigPath, extraFileExtensions) {
+        const createAbstractBuilder = (...args) => {
+            const [rootNames, options, argHost, oldProgram, configFileParsingDiagnostics, projectReferences] = args
+
+            const host = argHost
+            if (!this.patchedHostSet.has(host)) {
+                this.patchedHostSet.add(host)
+
+                const getTargetSourceFile = (fileName, languageVersionOrOptions) => {
+                    if (
+                        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
+                }
+
+                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,
+                        languageVersionOrOptions,
+                        ...args,
+                    )
+                    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,
+                        path,
+                        languageVersionOrOptions,
+                        ...args,
+                    )
+                    return getTargetSourceFile(fileName, languageVersionOrOptions) ?? originalSourceFile
+                }
+            }
+            return ts.createAbstractBuilder(
+                rootNames,
+                options,
+                host,
+                oldProgram,
+                configFileParsingDiagnostics,
+                projectReferences,
+            )
+        }
+
+        const watchCompilerHost = ts.createWatchCompilerHost(
+            tsconfigPath,
+            {
+                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,
+            createAbstractBuilder,
+            (diagnostic) => {
+                throw new Error(formatDiagnostics([diagnostic]))
+            },
+            () => {
+                // Not reported in reportWatchStatus.
+            },
+            undefined,
+            extraFileExtensions.map((extension) => ({
+                extension,
+                isMixedContent: true,
+                scriptKind: ts.ScriptKind.Deferred,
+            })),
+        )
+        const original = {
+            readFile: watchCompilerHost.readFile,
+            fileExists: watchCompilerHost.fileExists,
+            readDirectory: watchCompilerHost.readDirectory,
+            directoryExists: watchCompilerHost.directoryExists,
+            getDirectories: watchCompilerHost.getDirectories,
+        }
+        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))
+            )
+        }
+        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)
+                }
+            }
+
+            return distinctArray(...results)
+        }
+        watchCompilerHost.readFile = (fileName, ...args) => {
+            const realFileName = getRealFileNameIfExist(fileName)
+            if (realFileName == undefined) {
+                return
+            }
+            if (this.currTarget.filePath === realFileName) {
+                // It is the file currently being parsed.
+                return transformExtraFile(this.currTarget.code, {
+                    filePath: realFileName,
+                    current: true,
+                })
+            }
+
+            const code = original.readFile.call(watchCompilerHost, realFileName, ...args)
+            if (!code) {
+                return code
+            }
+            return transformExtraFile(code, {
+                filePath: realFileName,
+                current: false,
+            })
+        }
+        // Modify it so that it can be determined that the virtual file actually exists.
+        watchCompilerHost.fileExists = (fileName) => {
+            return getRealFileNameIfExist(fileName) != undefined
+        }
+
+        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
+            }
+            if (this.currTarget.filePath === normalizedFileName) {
+                // It is the file currently being parsed.
+                return normalizedFileName
+            }
+            const exists = original.fileExists.call(watchCompilerHost, normalizedFileName)
+            if (exists) {
+                return normalizedFileName
+            }
+            if (isVirtualTSX(normalizedFileName, extraFileExtensions)) {
+                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
+                    }
+                }
+                if (original.fileExists.call(watchCompilerHost, real)) {
+                    return real
+                }
+            }
+            return
+        }
+
+        // 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, {
+                update: () => callback(fileName, ts.FileWatcherEventKind.Changed),
+            })
+
+            return {
+                close: () => {
+                    this.fileWatchCallbacks.delete(normalized)
+                },
+            }
+        }
+        // Use watchCompilerHost but don't actually watch the files and directories.
+        watchCompilerHost.watchDirectory = () => {
+            return {
+                close: () => {
+                    // noop
+                },
+            }
+        }
+
+        /**
+         * 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,
+            )
+            if (configFileDiagnostics.length > 0) {
+                throw new Error(formatDiagnostics(configFileDiagnostics))
+            }
+        }
+
+        const watch = ts.createWatchProgram(watchCompilerHost)
+        return watch
+    }
+}
+
+/** If the given filename has extra extensions, returns the d.ts filename. */
+function toExtraDtsFileNames(fileName, extraFileExtensions) {
+    const ext = getExtIfExtra(fileName, extraFileExtensions)
+    if (ext != undefined) {
+        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
+}
+
+/** 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
+}
+
+/** Checks the given filename is virtual file tsx or not. */
+function isVirtualTSX(fileName, extraFileExtensions) {
+    for (const extraFileExtension of extraFileExtensions) {
+        if (fileName.endsWith(`${extraFileExtension}.tsx`)) {
+            return true
+        }
+    }
+    return false
+}
+
+function formatDiagnostics(diagnostics) {
+    return ts.formatDiagnostics(diagnostics, {
+        getCanonicalFileName: (f) => f,
+        getCurrentDirectory: () => process.cwd(),
+        getNewLine: () => '\n',
+    })
+}
+
+function normalizeFileName(fileName) {
+    let normalized = path.normalize(fileName)
+    if (normalized.endsWith(path.sep)) {
+        normalized = normalized.slice(0, -1)
+    }
+    if (ts.sys.useCaseSensitiveFileNames) {
+        return toAbsolutePath(normalized)
+    }
+    return toAbsolutePath(normalized.toLowerCase())
+}
+
+function toAbsolutePath(filePath, baseDir) {
+    return path.isAbsolute(filePath) ? filePath : path.join(baseDir || process.cwd(), filePath)
+}
+
+function* iterateDirs(filePath) {
+    let target = filePath
+    let parent
+    while ((parent = path.dirname(target)) !== target) {
+        yield parent
+        target = parent
+    }
+}
+
+function distinctArray(...list) {
+    return [...new Set(ts.sys.useCaseSensitiveFileNames ? list : list.map((s) => s?.toLowerCase()))].filter(
+        (s) => s != undefined,
+    )
+}

package/src/typescript-eslint-parser-for-extra-files/utils/get-project-config-files.js

@@ -0,0 +1,25 @@
+import fs from 'node:fs'
+import path from 'node:path'
+
+export function getProjectConfigFiles(options) {
+    if (options.project !== true) {
+        return Array.isArray(options.project) ? options.project : [options.project]
+    }
+
+    let directory = path.dirname(options.filePath)
+    const checkedDirectories = [directory]
+
+    do {
+        const tsconfigPath = path.join(directory, 'tsconfig.json')
+        if (fs.existsSync(tsconfigPath)) {
+            return [tsconfigPath]
+        }
+
+        directory = path.dirname(directory)
+        checkedDirectories.push(directory)
+    } while (directory.length > 1 && directory.length >= options.tsconfigRootDir.length)
+
+    throw new Error(
+        `project was set to \`true\` but couldn't find any tsconfig.json relative to '${options.filePath}' within '${options.tsconfigRootDir}'.`,
+    )
+}

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

@@ -0,0 +1,63 @@
+import path from 'node:path'
+import ts from 'typescript'
+import { globbySync } from 'globby'
+import isGlob from 'is-glob'
+/**
+ * Normalizes, sanitizes, resolves and filters the provided project paths
+ */
+export function resolveProjectList(options) {
+    const sanitizedProjects = []
+
+    // Normalize and sanitize the project paths
+    if (options.project) {
+        for (const project of options.project) {
+            if (typeof project === 'string') {
+                sanitizedProjects.push(project)
+            }
+        }
+    }
+
+    if (sanitizedProjects.length === 0) {
+        return []
+    }
+
+    const projectFolderIgnoreList = []
+    for (const folder of options.projectFolderIgnoreList ?? ['**/node_modules/**']) {
+        if (typeof folder === 'string') {
+            projectFolderIgnoreList.push(folder.startsWith('!') ? folder : `!${folder}`)
+        }
+    }
+
+    // Transform glob patterns into paths
+    const nonGlobProjects = sanitizedProjects.filter((project) => !isGlob(project))
+    const globProjects = sanitizedProjects.filter((project) => isGlob(project))
+
+    const uniqueCanonicalProjectPaths = new Set(
+        [
+            ...nonGlobProjects,
+            ...(globProjects.length === 0
+                ? []
+                : globbySync([...globProjects, ...projectFolderIgnoreList], {
+                      cwd: options.tsconfigRootDir,
+                  })),
+        ].map((project) => getCanonicalFileName(ensureAbsolutePath(project, options.tsconfigRootDir))),
+    )
+
+    return [...uniqueCanonicalProjectPaths]
+}
+
+// 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()
+
+function getCanonicalFileName(filePath) {
+    let normalized = path.normalize(filePath)
+    if (normalized.endsWith(path.sep)) {
+        normalized = normalized.slice(0, -1)
+    }
+    return correctPathCasing(normalized)
+}
+
+function ensureAbsolutePath(p, tsconfigRootDir) {
+    return path.isAbsolute(p) ? p : path.join(tsconfigRootDir || process.cwd(), p)
+}

package/tsconfig.json

@@ -0,0 +1,14 @@
+{
+    "exclude": ["node_modules", "dist"],
+    "compilerOptions": {
+        "baseUrl": ".",
+        "noImplicitOverride": true,
+        "target": "ESNext",
+        "module": "Preserve",
+        "resolveJsonModule": true,
+        "moduleResolution": "Bundler",
+        "lib": ["ESNext"],
+        "esModuleInterop": true,
+        "strictNullChecks": true
+    }
+}