@tsslint/core 1.0.16 → 1.0.18

package/index.d.ts

@@ -3,7 +3,7 @@ export * from './lib/watch';
 import type { Config, ProjectContext } from '@tsslint/types';
 import type * as ts from 'typescript';
 export type Linter = ReturnType<typeof createLinter>;
-export declare function createLinter(ctx: ProjectContext, config: Config, withStack: boolean): {
+export declare function createLinter(ctx: ProjectContext, config: Config | Config[], withStack: boolean): {
     lint(fileName: string): ts.DiagnosticWithLocation[];
     hasCodeFixes(fileName: string): boolean;
     getCodeFixes(fileName: string, start: number, end: number, diagnostics?: ts.Diagnostic[]): ts.CodeFixAction[];

package/index.js

@@ -44,24 +44,26 @@ function createLinter(ctx, config, withStack) {
     const fileFixes = new Map();
     const fileRefactors = new Map();
     const sourceFiles = new Map();
-    const plugins = (config.plugins ?? []).map(plugin => plugin(ctx));
-    const includes = [];
-    const excludes = [];
-    for (const include of config.include ?? []) {
-        const basePath = path.dirname(ctx.configFile);
-        includes.push([include, path.resolve(basePath, include)]);
-    }
-    for (const exclude of config.exclude ?? []) {
-        const basePath = path.dirname(ctx.configFile);
-        excludes.push([exclude, path.resolve(basePath, exclude)]);
-    }
+    const basePath = path.dirname(ctx.configFile);
+    const configs = (Array.isArray(config) ? config : [config])
+        .map(config => ({
+        config,
+        includes: (config.include ?? []).map(include => {
+            return path.resolve(basePath, include);
+        }),
+        excludes: (config.exclude ?? []).map(exclude => {
+            return path.resolve(basePath, exclude);
+        }),
+    }));
+    const plugins = configs.map(({ config }) => config.plugins ?? []).flat().map(plugin => plugin(ctx));
+    const debug = configs.some(({ config }) => config.debug);
     return {
         lint(fileName) {
             let diagnostics = [];
             let debugInfo;
-            if (config.debug) {
+            if (debug) {
                 debugInfo = {
-                    category: ts.DiagnosticCategory.Message,
+                    category: ts.DiagnosticCategory.Suggestion,
                     code: 'debug',
                     messageText: '- Config: ' + ctx.configFile + '\n',
                     file: ctx.languageService.getProgram().getSourceFile(fileName),
@@ -72,36 +74,12 @@ function createLinter(ctx, config, withStack) {
                 };
                 diagnostics.push(debugInfo);
             }
-            for (const [exclude, pattern] of excludes) {
-                if (minimatch.minimatch(fileName, pattern)) {
-                    if (debugInfo) {
-                        debugInfo.messageText += '- Included: ❌ (via ' + JSON.stringify({ exclude: [exclude] }) + ')\n';
-                    }
-                    return diagnostics;
-                }
-            }
-            if (includes.length) {
-                let included = false;
-                for (const [include, pattern] of includes) {
-                    if (minimatch.minimatch(fileName, pattern)) {
-                        included = true;
-                        if (debugInfo) {
-                            debugInfo.messageText += '- Included: ✅ (via ' + JSON.stringify({ include: [include] }) + ')\n';
-                        }
-                        break;
-                    }
-                }
-                if (!included) {
-                    if (debugInfo) {
-                        debugInfo.messageText += '- Included: ❌ (not included in any include patterns)\n';
-                    }
-                    return diagnostics;
-                }
-            }
-            else {
+            const rules = getFileRules(fileName);
+            if (!rules || !Object.keys(rules).length) {
                 if (debugInfo) {
-                    debugInfo.messageText += '- Included: ✅ (no include patterns)\n';
+                    debugInfo.messageText += '- Rules: ❌ (no rules)\n';
                 }
+                return diagnostics;
             }
             const sourceFile = ctx.languageService.getProgram()?.getSourceFile(fileName);
             if (!sourceFile) {
@@ -115,7 +93,6 @@ function createLinter(ctx, config, withStack) {
                 reportSuggestion,
             };
             const token = ctx.languageServiceHost.getCancellationToken?.();
-            const rules = getFileRules(sourceFile.fileName);
             const fixes = getFileFixes(sourceFile.fileName);
             const refactors = getFileRefactors(sourceFile.fileName);
             let currentRuleId;
@@ -265,7 +242,9 @@ function createLinter(ctx, config, withStack) {
             }
             function pushRelatedInformation(error, stack) {
                 if (stack.fileName && stack.lineNumber !== undefined && stack.columnNumber !== undefined) {
-                    let fileName = stack.fileName.replace(/\\/g, '/');
+                    let fileName = stack.fileName
+                        .replace(/\\/g, '/')
+                        .split('?time=')[0];
                     if (fileName.startsWith('file://')) {
                         fileName = fileName.substring('file://'.length);
                     }
@@ -366,7 +345,19 @@ function createLinter(ctx, config, withStack) {
     function getFileRules(fileName) {
         let rules = fileRules.get(fileName);
         if (!rules) {
-            rules = { ...config.rules };
+            rules = {};
+            for (const { config, includes, excludes } of configs) {
+                if (!config.rules) {
+                    continue;
+                }
+                if (excludes.some(pattern => minimatch.minimatch(fileName, pattern))) {
+                    continue;
+                }
+                if (includes.length && !includes.some(pattern => minimatch.minimatch(fileName, pattern))) {
+                    continue;
+                }
+                rules = { ...rules, ...config.rules };
+            }
             for (const plugin of plugins) {
                 if (plugin.resolveRules) {
                     rules = plugin.resolveRules(fileName, rules);

package/lib/build.d.ts

@@ -1,2 +1,2 @@
 import type { Config } from '@tsslint/config';
-export declare function buildConfigFile(configFilePath: string, createHash?: (path: string) => string, logger?: Pick<typeof console, 'log' | 'warn' | 'error'>): Promise<Config>;
+export declare function buildConfigFile(configFilePath: string, createHash?: (path: string) => string, logger?: Pick<typeof console, 'log' | 'warn' | 'error'>): Promise<Config | Config[]>;

package/lib/watch.d.ts

@@ -1,6 +1,6 @@
 import esbuild = require('esbuild');
 import type { Config } from '@tsslint/config';
-export declare function watchConfigFile(configFilePath: string, onBuild: (config: Config | undefined, result: esbuild.BuildResult) => void, watch?: boolean, createHash?: (path: string) => string, logger?: Pick<typeof console, 'log' | 'warn' | 'error'>): Promise<esbuild.BuildContext<{
+export declare function watchConfigFile(configFilePath: string, onBuild: (config: Config | Config[] | undefined, result: esbuild.BuildResult) => void, watch?: boolean, createHash?: (path: string) => string, logger?: Pick<typeof console, 'log' | 'warn' | 'error'>): Promise<esbuild.BuildContext<{
     entryPoints: string[];
     bundle: true;
     sourcemap: true;

package/lib/watch.js

@@ -46,9 +46,9 @@ async function watchConfigFile(configFilePath, onBuild, watch = true, createHash
                         if (!path.endsWith('.ts')) {
                             try {
                                 const maybeJsPath = require.resolve(path, { paths: [resolveDir] });
-                                if (!maybeJsPath.endsWith('.ts')) {
+                                if (maybeJsPath !== path && !maybeJsPath.endsWith('.ts')) {
                                     return {
-                                        path: maybeJsPath,
+                                        path: 'file://' + maybeJsPath,
                                         external: true,
                                     };
                                 }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@tsslint/core",
-	"version": "1.0.16",
+	"version": "1.0.18",
 	"license": "MIT",
 	"files": [
 		"**/*.js",
@@ -12,11 +12,11 @@
 		"directory": "packages/core"
 	},
 	"dependencies": {
-		"@tsslint/types": "1.0.16",
+		"@tsslint/types": "1.0.18",
 		"error-stack-parser": "^2.1.4",
 		"esbuild": "^0.23.0",
 		"minimatch": "^10.0.1",
 		"source-map-support": "^0.5.21"
 	},
-	"gitHead": "e430814fd394da5afbcd3157d02c246592162f75"
+	"gitHead": "95545c63940a9b57651c785cf4d730d6c3d22b99"
 }

package/lib/linter.d.ts

@@ -1,12 +0,0 @@
-import type { Config, ProjectContext } from '@tsslint/types';
-import type * as ts from 'typescript';
-export type Linter = ReturnType<typeof createLinter>;
-export declare function createLinter(ctx: ProjectContext, config: Config, withStack: boolean): {
-    lint(fileName: string): ts.DiagnosticWithLocation[];
-    hasCodeFixes(fileName: string): boolean;
-    getCodeFixes(fileName: string, start: number, end: number, diagnostics?: ts.Diagnostic[]): ts.CodeFixAction[];
-    getRefactors(fileName: string, start: number, end: number): ts.RefactorActionInfo[];
-    getRefactorEdits(fileName: string, name: string): ts.FileTextChanges[] | undefined;
-};
-export declare function combineCodeFixes(fileName: string, fixes: ts.CodeFixAction[]): ts.TextChange[];
-export declare function applyTextChanges(baseSnapshot: ts.IScriptSnapshot, textChanges: ts.TextChange[]): ts.IScriptSnapshot;

package/lib/linter.js

@@ -1,342 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createLinter = createLinter;
-exports.combineCodeFixes = combineCodeFixes;
-exports.applyTextChanges = applyTextChanges;
-const ErrorStackParser = require("error-stack-parser");
-const path = require("path");
-const minimatch = require("minimatch");
-function createLinter(ctx, config, withStack) {
-    if (withStack) {
-        require('source-map-support').install({
-            retrieveFile(path) {
-                // monkey-fix, refs: https://github.com/typescript-eslint/typescript-eslint/issues/9352
-                if (path.replace(/\\/g, '/').includes('/@typescript-eslint/eslint-plugin/dist/rules/') && path.endsWith('.js.map')) {
-                    return JSON.stringify({
-                        version: 3,
-                        sources: [],
-                        sourcesContent: [],
-                        mappings: '',
-                        names: [],
-                    });
-                }
-            },
-        });
-    }
-    const ts = ctx.typescript;
-    const fileRules = new Map();
-    const fileFixes = new Map();
-    const fileRefactors = new Map();
-    const sourceFiles = new Map();
-    const plugins = (config.plugins ?? []).map(plugin => plugin(ctx));
-    const excludes = [];
-    for (let exclude of config.exclude ?? []) {
-        const basePath = path.dirname(ctx.configFile);
-        excludes.push(path.resolve(basePath, exclude));
-    }
-    return {
-        lint(fileName) {
-            if (excludes.some(pattern => minimatch.minimatch(fileName, pattern))) {
-                return [];
-            }
-            const sourceFile = ctx.languageService.getProgram()?.getSourceFile(fileName);
-            if (!sourceFile) {
-                throw new Error(`No source file found for ${fileName}`);
-            }
-            const rulesContext = {
-                ...ctx,
-                sourceFile,
-                reportError,
-                reportWarning,
-                reportSuggestion,
-            };
-            const token = ctx.languageServiceHost.getCancellationToken?.();
-            const rules = getFileRules(sourceFile.fileName);
-            const fixes = getFileFixes(sourceFile.fileName);
-            const refactors = getFileRefactors(sourceFile.fileName);
-            let diagnostics = [];
-            let currentRuleId;
-            fixes.clear();
-            refactors.clear();
-            for (const [id, rule] of Object.entries(rules)) {
-                if (token?.isCancellationRequested()) {
-                    break;
-                }
-                currentRuleId = id;
-                try {
-                    rule(rulesContext);
-                }
-                catch (err) {
-                    diagnostics.push({
-                        category: ts.DiagnosticCategory.Error,
-                        code: id,
-                        messageText: String(err),
-                        file: sourceFile,
-                        start: 0,
-                        length: 0,
-                        source: 'tsslint',
-                        relatedInformation: [],
-                    });
-                }
-            }
-            for (const plugin of plugins) {
-                if (plugin.resolveDiagnostics) {
-                    diagnostics = plugin.resolveDiagnostics(sourceFile.fileName, diagnostics);
-                }
-            }
-            const diagnosticSet = new Set(diagnostics);
-            for (const [ruleId, fix] of [...fixes]) {
-                const final = fix.filter(fix => diagnosticSet.has(fix.diagnostic));
-                if (final.length) {
-                    fixes.set(ruleId, final);
-                }
-                else {
-                    fixes.delete(ruleId);
-                }
-            }
-            for (const [ruleId, refactor] of [...refactors]) {
-                const final = refactor.filter(fix => diagnosticSet.has(fix.diagnostic));
-                if (final.length) {
-                    refactors.set(ruleId, final);
-                }
-                else {
-                    refactors.delete(ruleId);
-                }
-            }
-            return diagnostics;
-            function reportError(message, start, end, traceOffset = 0) {
-                return report(ts.DiagnosticCategory.Error, message, start, end, traceOffset);
-            }
-            function reportWarning(message, start, end, traceOffset = 0) {
-                return report(ts.DiagnosticCategory.Warning, message, start, end, traceOffset);
-            }
-            function reportSuggestion(message, start, end, traceOffset = 0) {
-                return report(ts.DiagnosticCategory.Suggestion, message, start, end, traceOffset);
-            }
-            function report(category, message, start, end, traceOffset) {
-                const error = {
-                    category,
-                    code: currentRuleId,
-                    messageText: message,
-                    file: sourceFile,
-                    start,
-                    length: end - start,
-                    source: 'tsslint',
-                    relatedInformation: [],
-                };
-                if (withStack) {
-                    const stacks = traceOffset === false
-                        ? []
-                        : ErrorStackParser.parse(new Error());
-                    if (typeof traceOffset === 'number') {
-                        const baseOffset = 2 + traceOffset;
-                        if (stacks.length > baseOffset) {
-                            pushRelatedInformation(error, stacks[baseOffset]);
-                        }
-                    }
-                }
-                diagnostics.push(error);
-                return {
-                    withDeprecated() {
-                        error.reportsDeprecated = true;
-                        return this;
-                    },
-                    withUnnecessary() {
-                        error.reportsUnnecessary = true;
-                        return this;
-                    },
-                    withFix(title, getEdits) {
-                        if (!fixes.has(currentRuleId)) {
-                            fixes.set(currentRuleId, []);
-                        }
-                        fixes.get(currentRuleId).push(({
-                            diagnostic: error,
-                            title,
-                            start,
-                            end,
-                            getEdits,
-                        }));
-                        return this;
-                    },
-                    withRefactor(title, getEdits) {
-                        if (!refactors.has(currentRuleId)) {
-                            refactors.set(currentRuleId, []);
-                        }
-                        refactors.get(currentRuleId).push(({
-                            diagnostic: error,
-                            title,
-                            start,
-                            end,
-                            getEdits,
-                        }));
-                        return this;
-                    },
-                };
-            }
-            function pushRelatedInformation(error, stack) {
-                if (stack.fileName && stack.lineNumber !== undefined && stack.columnNumber !== undefined) {
-                    let fileName = stack.fileName.replace(/\\/g, '/');
-                    if (fileName.startsWith('file://')) {
-                        fileName = fileName.substring('file://'.length);
-                    }
-                    if (fileName.includes('http-url:')) {
-                        fileName = fileName.split('http-url:')[1];
-                    }
-                    if (!sourceFiles.has(fileName)) {
-                        const text = ctx.languageServiceHost.readFile(fileName) ?? '';
-                        sourceFiles.set(fileName, ts.createSourceFile(fileName, text, ts.ScriptTarget.Latest, true));
-                    }
-                    const stackFile = sourceFiles.get(fileName);
-                    let pos = 0;
-                    try {
-                        pos = stackFile?.getPositionOfLineAndCharacter(stack.lineNumber - 1, stack.columnNumber - 1) ?? 0;
-                    }
-                    catch { }
-                    error.relatedInformation?.push({
-                        category: ts.DiagnosticCategory.Message,
-                        code: 0,
-                        file: stackFile,
-                        start: pos,
-                        length: 0,
-                        messageText: 'at ' + (stack.functionName ?? '<anonymous>'),
-                    });
-                }
-            }
-        },
-        hasCodeFixes(fileName) {
-            const fixesMap = getFileFixes(fileName);
-            for (const [_ruleId, fixes] of fixesMap) {
-                if (fixes.length) {
-                    return true;
-                }
-            }
-            return false;
-        },
-        getCodeFixes(fileName, start, end, diagnostics) {
-            const fixesMap = getFileFixes(fileName);
-            let result = [];
-            for (const [ruleId, fixes] of fixesMap) {
-                for (let i = 0; i < fixes.length; i++) {
-                    const fix = fixes[i];
-                    if (diagnostics?.length && !diagnostics.includes(fix.diagnostic)) {
-                        continue;
-                    }
-                    if ((fix.start >= start && fix.start <= end) ||
-                        (fix.end >= start && fix.end <= end) ||
-                        (start >= fix.start && start <= fix.end) ||
-                        (end >= fix.start && end <= fix.end)) {
-                        result.push({
-                            fixName: `tsslint:${ruleId}`,
-                            description: fix.title,
-                            changes: fix.getEdits(),
-                            fixId: 'tsslint',
-                            fixAllDescription: 'Fix all TSSLint errors'
-                        });
-                    }
-                }
-            }
-            for (const plugin of plugins) {
-                if (plugin.resolveCodeFixes) {
-                    result = plugin.resolveCodeFixes(fileName, result);
-                }
-            }
-            return result;
-        },
-        getRefactors(fileName, start, end) {
-            const refactorsMap = getFileRefactors(fileName);
-            let result = [];
-            for (const [ruleId, refactors] of refactorsMap) {
-                for (let i = 0; i < refactors.length; i++) {
-                    const refactor = refactors[i];
-                    if ((refactor.start >= start && refactor.start <= end) ||
-                        (refactor.end >= start && refactor.end <= end) ||
-                        (start >= refactor.start && start <= refactor.end) ||
-                        (end >= refactor.start && end <= refactor.end)) {
-                        result.push({
-                            name: `tsslint:${ruleId}:${i}`,
-                            description: refactor.title + ' (' + ruleId + ')',
-                            kind: 'quickfix',
-                        });
-                    }
-                }
-            }
-            return result;
-        },
-        getRefactorEdits(fileName, name) {
-            if (name.startsWith('tsslint:')) {
-                const [ruleId, index] = name.slice('tsslint:'.length).split(':');
-                const refactorsMap = getFileRefactors(fileName);
-                const refactor = refactorsMap.get(ruleId)?.[Number(index)];
-                if (refactor) {
-                    return refactor.getEdits();
-                }
-            }
-        },
-    };
-    function getFileRules(fileName) {
-        let rules = fileRules.get(fileName);
-        if (!rules) {
-            rules = { ...config.rules };
-            for (const plugin of plugins) {
-                if (plugin.resolveRules) {
-                    rules = plugin.resolveRules(fileName, rules);
-                }
-            }
-            fileRules.set(fileName, rules);
-        }
-        return rules;
-    }
-    function getFileFixes(fileName) {
-        if (!fileFixes.has(fileName)) {
-            fileFixes.set(fileName, new Map());
-        }
-        return fileFixes.get(fileName);
-    }
-    function getFileRefactors(fileName) {
-        if (!fileRefactors.has(fileName)) {
-            fileRefactors.set(fileName, new Map());
-        }
-        return fileRefactors.get(fileName);
-    }
-}
-function combineCodeFixes(fileName, fixes) {
-    const changes = fixes
-        .map(fix => fix.changes)
-        .flat()
-        .filter(change => change.fileName === fileName && change.textChanges.length)
-        .sort((a, b) => b.textChanges[0].span.start - a.textChanges[0].span.start);
-    let lastChangeAt = Number.MAX_VALUE;
-    let finalTextChanges = [];
-    for (const change of changes) {
-        const textChanges = [...change.textChanges].sort((a, b) => a.span.start - b.span.start);
-        const firstChange = textChanges[0];
-        const lastChange = textChanges[textChanges.length - 1];
-        if (lastChangeAt >= lastChange.span.start + lastChange.span.length) {
-            lastChangeAt = firstChange.span.start;
-            finalTextChanges = finalTextChanges.concat(textChanges);
-        }
-    }
-    return finalTextChanges;
-}
-function applyTextChanges(baseSnapshot, textChanges) {
-    textChanges = [...textChanges].sort((a, b) => b.span.start - a.span.start);
-    let text = baseSnapshot.getText(0, baseSnapshot.getLength());
-    for (const change of textChanges) {
-        text = text.slice(0, change.span.start) + change.newText + text.slice(change.span.start + change.span.length);
-    }
-    return {
-        getText(start, end) {
-            return text.substring(start, end);
-        },
-        getLength() {
-            return text.length;
-        },
-        getChangeRange(oldSnapshot) {
-            if (oldSnapshot === baseSnapshot) {
-                // TODO
-            }
-            return undefined;
-        },
-    };
-}
-//# sourceMappingURL=linter.js.map