@tsslint/core 1.0.17 → 1.0.19

package/lib/watch.js

@@ -13,7 +13,7 @@ async function watchConfigFile(configFilePath, onBuild, watch = true, createHash
         let config;
         if (!result.errors.length) {
             try {
-                config = (await import(outFile + '?time=' + Date.now())).default;
+                config = (await import('file://' + outFile + '?time=' + Date.now())).default;
             }
             catch (e) {
                 result.errors.push({ text: String(e) });
@@ -46,7 +46,7 @@ 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,
                                         external: true,

package/package.json

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

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