@tsslint/core 1.3.5 → 1.4.0

package/index.d.ts

@@ -1,6 +1,6 @@
 export * from './lib/build';
 export * from './lib/watch';
-import type { Config, ProjectContext } from '@tsslint/types';
+import type { Config, ProjectContext, Rules } from '@tsslint/types';
 import type * as ts from 'typescript';
 export type FileLintCache = [
     mtime: number,
@@ -13,9 +13,17 @@ export type Linter = ReturnType<typeof createLinter>;
 export declare function createLinter(ctx: ProjectContext, config: Config | Config[], mode: 'cli' | 'typescript-plugin', logger?: typeof import('@clack/prompts')): {
     lint(fileName: string, cache?: FileLintCache): ts.DiagnosticWithLocation[];
     hasCodeFixes(fileName: string): boolean;
-    getCodeFixes(fileName: string, start: number, end: number, diagnostics?: ts.Diagnostic[], cache?: FileLintCache): ts.CodeFixAction[];
+    getCodeFixes(fileName: string, start: number, end: number, diagnostics?: ts.Diagnostic[], minimatchCache?: FileLintCache[4]): ts.CodeFixAction[];
     getRefactors(fileName: string, start: number, end: number): ts.RefactorActionInfo[];
     getRefactorEdits(fileName: string, actionName: string): ts.FileTextChanges[] | undefined;
+    getRules: (fileName: string, minimatchCache: undefined | FileLintCache[4]) => Rules;
+    getConfigs: (fileName: string, minimatchCache: undefined | FileLintCache[4]) => {
+        include: string[];
+        exclude: string[];
+        rules: Rules;
+        plugins: import("@tsslint/types").PluginInstance[];
+    }[];
 };
+export declare function createRelatedInformation(ts: typeof import('typescript'), err: Error, stackOffset: number): ts.DiagnosticRelatedInformation | 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/index.js

@@ -15,6 +15,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createLinter = createLinter;
+exports.createRelatedInformation = createRelatedInformation;
 exports.combineCodeFixes = combineCodeFixes;
 exports.applyTextChanges = applyTextChanges;
 __exportStar(require("./lib/build"), exports);
@@ -22,34 +23,18 @@ __exportStar(require("./lib/watch"), exports);
 const ErrorStackParser = require("error-stack-parser");
 const path = require("path");
 const minimatch = require("minimatch");
+const typeAwareModeChange = new Error('enable type-aware mode');
 function createLinter(ctx, config, mode, 
 // @ts-expect-error
 logger) {
-    if (mode === 'typescript-plugin') {
-        require('source-map-support').install({
-            retrieveFile(path) {
-                if (!path.endsWith('.js.map')) {
-                    return;
-                }
-                path = path.replace(/\\/g, '/');
-                // monkey-fix, refs: https://github.com/typescript-eslint/typescript-eslint/issues/9352
-                if (path.includes('/@typescript-eslint/eslint-plugin/dist/rules/')
-                    || path.includes('/eslint-plugin-expect-type/lib/rules/')) {
-                    return JSON.stringify({
-                        version: 3,
-                        sources: [],
-                        sourcesContent: [],
-                        mappings: '',
-                        names: [],
-                    });
-                }
-            },
-        });
-    }
-    let languageServiceUsage = mode === 'typescript-plugin' ? 1 : 0;
+    let languageServiceUsage = 0;
     const ts = ctx.typescript;
     const languageService = new Proxy(ctx.languageService, {
         get(target, key, receiver) {
+            if (!languageServiceUsage) {
+                languageServiceUsage++;
+                throw typeAwareModeChange;
+            }
             languageServiceUsage++;
             return Reflect.get(target, key, receiver);
         },
@@ -58,7 +43,6 @@ logger) {
     const fileConfigs = new Map();
     const fileFixes = new Map();
     const fileRefactors = new Map();
-    const sourceFiles = new Map();
     const snapshot2SourceFile = new WeakMap();
     const basePath = path.dirname(ctx.configFile);
     const configs = (Array.isArray(config) ? config : [config])
@@ -69,12 +53,10 @@ logger) {
         plugins: (config.plugins ?? []).map(plugin => plugin(ctx)),
     }));
     const normalizedPath = new Map();
-    const debug = (Array.isArray(config) ? config : [config]).some(config => config.debug);
     return {
         lint(fileName, cache) {
             let cacheableDiagnostics = [];
             let uncacheableDiagnostics = [];
-            let debugInfo;
             let currentRuleId;
             let currentIssues = 0;
             let currentFixes = 0;
@@ -82,26 +64,7 @@ logger) {
             let currentRuleLanguageServiceUsage = 0;
             let sourceFile;
             let hasUncacheResult = false;
-            if (debug) {
-                debugInfo = {
-                    category: ts.DiagnosticCategory.Message,
-                    code: 'debug',
-                    messageText: '- Config: ' + ctx.configFile + '\n',
-                    file: getSourceFile(fileName),
-                    start: 0,
-                    length: 0,
-                    source: 'tsslint',
-                    relatedInformation: [],
-                };
-                uncacheableDiagnostics.push(debugInfo);
-            }
-            const rules = getFileRules(fileName, cache);
-            if (!rules || !Object.keys(rules).length) {
-                if (debugInfo) {
-                    debugInfo.messageText += '- Rules: ❌ (no rules)\n';
-                }
-            }
-            const prevLanguageServiceUsage = languageServiceUsage;
+            const rules = getFileRules(fileName, cache?.[4]);
             const rulesContext = {
                 ...ctx,
                 languageService,
@@ -123,14 +86,10 @@ logger) {
             }
             fixes.clear();
             refactors.length = 0;
-            if (debugInfo) {
-                debugInfo.messageText += '- Rules:\n';
-            }
-            runRules(rules);
-            if (!!prevLanguageServiceUsage !== !!languageServiceUsage) {
+            if (!runRules(rules)) {
                 return this.lint(fileName, cache);
             }
-            const configs = getFileConfigs(fileName, cache);
+            const configs = getFileConfigs(fileName, cache?.[4]);
             if (cache) {
                 for (const [ruleId, fixes] of cachedRules) {
                     cache[1][ruleId] = fixes;
@@ -193,7 +152,9 @@ logger) {
                         break;
                     }
                     if (typeof rule === 'object') {
-                        runRules(rule, [...paths, path]);
+                        if (!runRules(rule, [...paths, path])) {
+                            return false;
+                        }
                         continue;
                     }
                     currentRuleLanguageServiceUsage = languageServiceUsage;
@@ -205,56 +166,38 @@ logger) {
                         continue;
                     }
                     hasUncacheResult = true;
-                    const start = Date.now();
                     try {
                         rule(rulesContext);
-                        if (debugInfo) {
-                            const time = Date.now() - start;
-                            debugInfo.messageText += `  - ${currentRuleId}`;
-                            const details = [];
-                            if (currentIssues) {
-                                details.push(`${currentIssues} issues`);
-                            }
-                            if (currentFixes) {
-                                details.push(`${currentFixes} fixes`);
-                            }
-                            if (currentRefactors) {
-                                details.push(`${currentRefactors} refactors`);
-                            }
-                            if (time) {
-                                details.push(`${time}ms`);
-                            }
-                            if (details.length) {
-                                debugInfo.messageText += ` (${details.join(', ')})`;
-                            }
-                            debugInfo.messageText += '\n';
-                        }
                     }
                     catch (err) {
-                        console.error(err);
-                        if (debugInfo) {
-                            debugInfo.messageText += `  - ${currentRuleId} (❌ ${err && typeof err === 'object' && 'stack' in err ? err.stack : String(err)}})\n`;
+                        if (err === typeAwareModeChange) {
+                            // logger?.log.message(`Type-aware mode enabled by ${currentRuleId} rule.`);
+                            return false;
+                        }
+                        else if (err instanceof Error) {
+                            report(ts.DiagnosticCategory.Error, err.stack ?? err.message, 0, 0, 0, err);
+                        }
+                        else {
+                            report(ts.DiagnosticCategory.Error, String(err), 0, 0, false);
                         }
-                    }
-                    if (debug && !!currentRuleLanguageServiceUsage !== !!languageServiceUsage) {
-                        logger?.log.message(`Type-aware mode enabled by ${currentRuleId} rule.`);
                     }
                     if (cache && currentRuleLanguageServiceUsage === languageServiceUsage) {
                         cachedRules.set(currentRuleId, currentFixes);
                     }
                 }
+                return true;
             }
             ;
-            function reportError(message, start, end, traceOffset = 0) {
-                return report(ts.DiagnosticCategory.Error, message, start, end, traceOffset);
+            function reportError(message, start, end, stackOffset) {
+                return report(ts.DiagnosticCategory.Error, message, start, end, stackOffset);
             }
-            function reportWarning(message, start, end, traceOffset = 0) {
-                return report(ts.DiagnosticCategory.Warning, message, start, end, traceOffset);
+            function reportWarning(message, start, end, stackOffset) {
+                return report(ts.DiagnosticCategory.Warning, message, start, end, stackOffset);
             }
-            function reportSuggestion(message, start, end, traceOffset = 0) {
-                return report(ts.DiagnosticCategory.Suggestion, message, start, end, traceOffset);
+            function reportSuggestion(message, start, end, stackOffset) {
+                return report(ts.DiagnosticCategory.Suggestion, message, start, end, stackOffset);
             }
-            function report(category, message, start, end, traceOffset) {
+            function report(category, message, start, end, stackOffset = 2, err) {
                 const error = {
                     category,
                     code: currentRuleId,
@@ -276,15 +219,11 @@ logger) {
                         })),
                     });
                 }
-                if (mode === 'typescript-plugin') {
-                    const stacks = traceOffset === false
-                        ? []
-                        : ErrorStackParser.parse(new Error());
-                    if (typeof traceOffset === 'number') {
-                        const baseOffset = 2 + traceOffset;
-                        if (stacks.length > baseOffset) {
-                            pushRelatedInformation(error, stacks[baseOffset]);
-                        }
+                if (mode === 'typescript-plugin' && typeof stackOffset === 'number') {
+                    err ??= new Error();
+                    const relatedInfo = createRelatedInformation(ts, err, stackOffset);
+                    if (relatedInfo) {
+                        error.relatedInformation.push(relatedInfo);
                     }
                 }
                 fixes.set(error, []);
@@ -315,43 +254,6 @@ logger) {
                     },
                 };
             }
-            function pushRelatedInformation(error, stack) {
-                if (stack.fileName && stack.lineNumber !== undefined && stack.columnNumber !== undefined) {
-                    let fileName = stack.fileName
-                        .replace(/\\/g, '/')
-                        .split('?time=')[0];
-                    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, [
-                            text !== undefined,
-                            ts.createSourceFile(fileName, text ?? '', ts.ScriptTarget.Latest, true)
-                        ]);
-                    }
-                    const [exist, stackFile] = sourceFiles.get(fileName);
-                    let pos = 0;
-                    if (exist) {
-                        try {
-                            pos = stackFile.getPositionOfLineAndCharacter(stack.lineNumber - 1, stack.columnNumber - 1) ?? 0;
-                        }
-                        catch { }
-                    }
-                    error.relatedInformation ??= [];
-                    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);
@@ -362,8 +264,8 @@ logger) {
             }
             return false;
         },
-        getCodeFixes(fileName, start, end, diagnostics, cache) {
-            const configs = getFileConfigs(fileName, cache);
+        getCodeFixes(fileName, start, end, diagnostics, minimatchCache) {
+            const configs = getFileConfigs(fileName, minimatchCache);
             const fixesMap = getFileFixes(fileName);
             const result = [];
             for (const [diagnostic, actions] of fixesMap) {
@@ -428,6 +330,8 @@ logger) {
                 }
             }
         },
+        getRules: getFileRules,
+        getConfigs: getFileConfigs,
     };
     function getSourceFile(fileName) {
         if (languageServiceUsage) {
@@ -446,11 +350,11 @@ logger) {
         }
         throw new Error('No source file');
     }
-    function getFileRules(fileName, cache) {
+    function getFileRules(fileName, minimatchCache) {
         let result = fileRules.get(fileName);
         if (!result) {
             result = {};
-            const configs = getFileConfigs(fileName, cache);
+            const configs = getFileConfigs(fileName, minimatchCache);
             for (const { rules } of configs) {
                 result = {
                     ...result,
@@ -468,7 +372,7 @@ logger) {
         }
         return result;
     }
-    function getFileConfigs(fileName, cache) {
+    function getFileConfigs(fileName, minimatchCache) {
         let result = fileConfigs.get(fileName);
         if (!result) {
             result = configs.filter(({ include, exclude }) => {
@@ -482,9 +386,9 @@ logger) {
             });
             fileConfigs.set(fileName, result);
             function _minimatch(pattern) {
-                if (cache) {
-                    if (pattern in cache[4]) {
-                        return cache[4][pattern];
+                if (minimatchCache) {
+                    if (pattern in minimatchCache) {
+                        return minimatchCache[pattern];
                     }
                 }
                 let normalized = normalizedPath.get(pattern);
@@ -493,8 +397,8 @@ logger) {
                     normalizedPath.set(pattern, normalized);
                 }
                 const res = minimatch.minimatch(fileName, normalized);
-                if (cache) {
-                    cache[4][pattern] = res;
+                if (minimatchCache) {
+                    minimatchCache[pattern] = res;
                 }
                 return res;
             }
@@ -514,6 +418,49 @@ logger) {
         return fileRefactors.get(fileName);
     }
 }
+const fsFiles = new Map();
+function createRelatedInformation(ts, err, stackOffset) {
+    const stacks = ErrorStackParser.parse(err);
+    if (stacks.length <= stackOffset) {
+        return;
+    }
+    const stack = stacks[stackOffset];
+    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];
+        }
+        const mtime = ts.sys.getModifiedTime?.(fileName)?.getTime() ?? 0;
+        const lastMtime = fsFiles.get(fileName)?.[1];
+        if (mtime !== lastMtime) {
+            const text = ts.sys.readFile(fileName);
+            fsFiles.set(fileName, [
+                text !== undefined,
+                mtime,
+                ts.createSourceFile(fileName, text ?? '', ts.ScriptTarget.Latest, true)
+            ]);
+        }
+        const [exist, _mtime, relatedFile] = fsFiles.get(fileName);
+        let pos = 0;
+        if (exist) {
+            try {
+                pos = relatedFile.getPositionOfLineAndCharacter(stack.lineNumber - 1, stack.columnNumber - 1) ?? 0;
+            }
+            catch { }
+        }
+        return {
+            category: ts.DiagnosticCategory.Message,
+            code: 0,
+            file: relatedFile,
+            start: pos,
+            length: 0,
+            messageText: 'at ' + (stack.functionName ?? '<anonymous>'),
+        };
+    }
+}
 function combineCodeFixes(fileName, fixes) {
     const changes = fixes
         .map(fix => fix.changes)

package/lib/build copy.d.ts

@@ -0,0 +1 @@
+export declare function buildConfig(configFilePath: string, createHash?: (path: string) => string, logger?: typeof import('@clack/prompts')): Promise<string>;

package/lib/build copy.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildConfig = buildConfig;
+const watch_1 = require("./watch");
+function buildConfig(configFilePath, createHash, 
+// @ts-expect-error
+logger) {
+    return new Promise((resolve, reject) => {
+        (0, watch_1.watchConfig)(configFilePath, (config, result) => {
+            if (config) {
+                resolve(config);
+            }
+            else {
+                reject(result);
+            }
+        }, false, createHash, logger);
+    });
+}
+//# sourceMappingURL=build%20copy.js.map

package/lib/build.d.ts

@@ -1,2 +1 @@
-import type { Config } from '@tsslint/config';
-export declare function buildConfigFile(configFilePath: string, createHash?: (path: string) => string, logger?: typeof import('@clack/prompts')): Promise<Config | Config[]>;
+export declare function buildConfig(configFilePath: string, createHash?: (path: string) => string, spinner?: ReturnType<typeof import('@clack/prompts').spinner>, stopSnipper?: (message: string, code?: number) => void): Promise<string | undefined>;

package/lib/build.js

@@ -1,19 +1,30 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.buildConfigFile = buildConfigFile;
+exports.buildConfig = buildConfig;
 const watch_1 = require("./watch");
-function buildConfigFile(configFilePath, createHash, 
+const _path = require("path");
+function buildConfig(configFilePath, createHash, 
 // @ts-expect-error
-logger) {
-    return new Promise((resolve, reject) => {
-        (0, watch_1.watchConfigFile)(configFilePath, (config, result) => {
-            if (config) {
-                resolve(config);
-            }
-            else {
-                reject(result);
-            }
-        }, false, createHash, logger);
+spinner, stopSnipper) {
+    const buildStart = Date.now();
+    const configFileDisplayPath = _path.relative(process.cwd(), configFilePath);
+    spinner?.message('Building ' + configFileDisplayPath);
+    return new Promise(async (resolve) => {
+        try {
+            await (0, watch_1.watchConfig)(configFilePath, builtConfig => {
+                if (builtConfig) {
+                    stopSnipper?.('Built ' + configFileDisplayPath + ' in ' + (Date.now() - buildStart) + 'ms');
+                }
+                else {
+                    stopSnipper?.('Failed to build ' + configFileDisplayPath + ' in ' + (Date.now() - buildStart) + 'ms', 1);
+                }
+                resolve(builtConfig);
+            }, false, createHash, spinner, stopSnipper);
+        }
+        catch (e) {
+            stopSnipper?.('Failed to build ' + configFileDisplayPath + ' in ' + (Date.now() - buildStart) + 'ms', 1);
+            resolve(undefined);
+        }
     });
 }
 //# sourceMappingURL=build.js.map

package/lib/load.js

@@ -0,0 +1,43 @@
+"use strict";
+// import type { Config } from '@tsslint/config';
+Object.defineProperty(exports, "__esModule", { value: true });
+// import url = require('url');
+// // import ErrorStackParser = require('error-stack-parser');
+// export async function loadConfig(outFile: string): Promise<Config | Config[]> {
+// 	// try {
+// 	return (await import(url.pathToFileURL(outFile).toString() + '?time=' + Date.now())).default;
+// 	// } catch (e: any) {
+// 	// 	if (e.stack) {
+// 	// 		const stack = ErrorStackParser.parse(e)[0];
+// 	// 		if (stack.fileName && stack.lineNumber !== undefined && stack.columnNumber !== undefined) {
+// 	// 			let fileName = stack.fileName
+// 	// 				.replace(/\\/g, '/')
+// 	// 				.split('?time=')[0];
+// 	// 			if (fileName.startsWith('file://')) {
+// 	// 				fileName = fileName.substring('file://'.length);
+// 	// 			}
+// 	// 			result.errors.push({
+// 	// 				id: 'config-import-error',
+// 	// 				text: String(e),
+// 	// 				location: {
+// 	// 					file: fileName,
+// 	// 					line: stack.lineNumber,
+// 	// 					column: stack.columnNumber - 1,
+// 	// 					lineText: '',
+// 	// 				},
+// 	// 			} as any);
+// 	// 		} else {
+// 	// 			result.errors.push({
+// 	// 				id: 'config-import-error',
+// 	// 				text: String(e),
+// 	// 			} as any);
+// 	// 		}
+// 	// 	} else {
+// 	// 		result.errors.push({
+// 	// 			id: 'config-import-error',
+// 	// 			text: String(e),
+// 	// 		} as any);
+// 	// 	}
+// 	// }
+// }
+//# sourceMappingURL=load.js.map

package/lib/watch.d.ts

@@ -1,6 +1,5 @@
 import esbuild = require('esbuild');
-import type { Config } from '@tsslint/config';
-export declare function watchConfigFile(configFilePath: string, onBuild: (config: Config | Config[] | undefined, result: esbuild.BuildResult) => void, watch?: boolean, createHash?: (path: string) => string, logger?: typeof import('@clack/prompts')): Promise<esbuild.BuildContext<{
+export declare function watchConfig(configFilePath: string, onBuild: (config: string | undefined, result: esbuild.BuildResult) => void, watch?: boolean, createHash?: (path: string) => string, spinner?: ReturnType<typeof import('@clack/prompts').spinner>, stopSnipper?: (message: string, code?: number) => void): Promise<esbuild.BuildContext<{
     entryPoints: string[];
     bundle: true;
     sourcemap: true;

package/lib/watch.js

@@ -1,83 +1,25 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.watchConfigFile = watchConfigFile;
+exports.watchConfig = watchConfig;
 exports.getDotTsslintPath = getDotTsslintPath;
 const esbuild = require("esbuild");
 const _path = require("path");
 const fs = require("fs");
 const url = require("url");
-const ErrorStackParser = require("error-stack-parser");
-async function watchConfigFile(configFilePath, onBuild, watch = true, createHash = btoa, 
+async function watchConfig(configFilePath, onBuild, watch = true, createHash = btoa, 
 // @ts-expect-error
-logger) {
+spinner, stopSnipper) {
     const outDir = getDotTsslintPath(configFilePath);
     const outFileName = createHash(_path.relative(outDir, configFilePath)) + '.mjs';
     const outFile = _path.join(outDir, outFileName);
-    const configFileDisplayPath = _path.relative(process.cwd(), configFilePath);
-    const resultHandler = async (result) => {
-        let config;
-        for (const error of [
-            ...result.errors,
-            ...result.warnings,
-        ]) {
-            if (error.id) {
-                error.id = 'esbuild:' + error.id;
-            }
-            else {
-                error.id = 'config-build-error';
-            }
-        }
-        const buildResultText = 'Built ' + configFileDisplayPath + ' in ' + (Date.now() - buildStart) + 'ms';
-        configBuildingSpinner?.message(buildResultText);
+    const resultHandler = (result) => {
         if (!result.errors.length) {
-            const loadStart = Date.now();
-            configBuildingSpinner?.message(buildResultText + ', importing...');
-            try {
-                config = (await import(url.pathToFileURL(outFile).toString() + '?time=' + Date.now())).default;
-                configBuildingSpinner?.stop(buildResultText + ', imported in ' + (Date.now() - loadStart) + 'ms.');
-            }
-            catch (e) {
-                configBuildingSpinner?.stop(buildResultText + ', failed to import.');
-                if (e.stack) {
-                    const stack = ErrorStackParser.parse(e)[0];
-                    if (stack.fileName && stack.lineNumber !== undefined && stack.columnNumber !== undefined) {
-                        let fileName = stack.fileName
-                            .replace(/\\/g, '/')
-                            .split('?time=')[0];
-                        if (fileName.startsWith('file://')) {
-                            fileName = fileName.substring('file://'.length);
-                        }
-                        result.errors.push({
-                            id: 'config-import-error',
-                            text: String(e),
-                            location: {
-                                file: fileName,
-                                line: stack.lineNumber,
-                                column: stack.columnNumber - 1,
-                                lineText: '',
-                            },
-                        });
-                    }
-                    else {
-                        result.errors.push({
-                            id: 'config-import-error',
-                            text: String(e),
-                        });
-                    }
-                }
-                else {
-                    result.errors.push({
-                        id: 'config-import-error',
-                        text: String(e),
-                    });
-                }
-            }
+            onBuild(outFile, result);
+        }
+        else {
+            onBuild(undefined, result);
         }
-        onBuild(config, result);
     };
-    let buildStart;
-    const configBuildingSpinner = logger?.spinner();
-    configBuildingSpinner?.start('Building ' + configFileDisplayPath);
     const ctx = await esbuild.context({
         entryPoints: [configFilePath],
         bundle: true,
@@ -88,18 +30,16 @@ logger) {
         plugins: [{
                 name: 'tsslint',
                 setup(build) {
-                    build.onStart(() => {
-                        buildStart = Date.now();
-                    });
                     build.onResolve({ filter: /^https?:\/\// }, async ({ path: importUrl }) => {
                         const cachePath = _path.join(outDir, importUrl.split('://')[0], ...importUrl.split('://')[1].split('/'));
                         if (!fs.existsSync(cachePath)) {
-                            configBuildingSpinner?.message('Downloading ' + importUrl);
+                            const start = Date.now();
+                            spinner?.message('Downloading ' + importUrl);
                             const response = await fetch(importUrl);
-                            configBuildingSpinner?.message('Building ' + configFileDisplayPath);
                             if (!response.ok) {
                                 throw new Error(`Failed to load ${importUrl}`);
                             }
+                            stopSnipper?.('Downloaded ' + importUrl + ' in ' + (Date.now() - start) + 'ms');
                             const text = await response.text();
                             fs.mkdirSync(_path.dirname(cachePath), { recursive: true });
                             fs.writeFileSync(cachePath, text, 'utf8');
@@ -142,9 +82,14 @@ logger) {
         await ctx.watch();
     }
     else {
-        const result = await ctx.rebuild();
-        await ctx.dispose();
-        resultHandler(result);
+        try {
+            const result = await ctx.rebuild(); // could throw
+            await ctx.dispose();
+            resultHandler(result);
+        }
+        catch (e) {
+            throw e;
+        }
     }
     return ctx;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@tsslint/core",
-	"version": "1.3.5",
+	"version": "1.4.0",
 	"license": "MIT",
 	"files": [
 		"**/*.js",
@@ -12,11 +12,10 @@
 		"directory": "packages/core"
 	},
 	"dependencies": {
-		"@tsslint/types": "1.3.5",
+		"@tsslint/types": "1.4.0",
 		"error-stack-parser": "^2.1.4",
 		"esbuild": ">=0.17.0",
-		"minimatch": "^10.0.1",
-		"source-map-support": "^0.5.21"
+		"minimatch": "^10.0.1"
 	},
 	"devDependencies": {
 		"@clack/prompts": "^0.8.2"
@@ -24,5 +23,5 @@
 	"scripts": {
 		"postinstall": "node scripts/cleanCache.js"
 	},
-	"gitHead": "6fd4e516735cdf1205a3fa0df91933de72f62476"
+	"gitHead": "9a3f7ce55f079eaaedfb61af9b72d8ba736f0123"
 }