@tsslint/core 1.3.1 → 1.3.3

package/index.d.ts

@@ -10,7 +10,7 @@ export type FileLintCache = [
     minimatchResult: Record<string, boolean>
 ];
 export type Linter = ReturnType<typeof createLinter>;
-export declare function createLinter(ctx: ProjectContext, config: Config | Config[], mode: 'cli' | 'typescript-plugin'): {
+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[];

package/index.js

@@ -22,7 +22,9 @@ __exportStar(require("./lib/watch"), exports);
 const ErrorStackParser = require("error-stack-parser");
 const path = require("path");
 const minimatch = require("minimatch");
-function createLinter(ctx, config, mode) {
+function createLinter(ctx, config, mode, 
+// @ts-expect-error
+logger) {
     if (mode === 'typescript-plugin') {
         require('source-map-support').install({
             retrieveFile(path) {
@@ -48,9 +50,6 @@ function createLinter(ctx, config, mode) {
     const ts = ctx.typescript;
     const languageService = new Proxy(ctx.languageService, {
         get(target, key, receiver) {
-            if (!languageServiceUsage && debug) {
-                console.log('Type-aware mode enabled');
-            }
             languageServiceUsage++;
             return Reflect.get(target, key, receiver);
         },
@@ -237,6 +236,9 @@ function createLinter(ctx, config, mode) {
                             debugInfo.messageText += `  - ${currentRuleId} (❌ ${err && typeof err === 'object' && 'stack' in err ? err.stack : String(err)}})\n`;
                         }
                     }
+                    if (debug && !!currentRuleLanguageServiceUsage !== !!languageServiceUsage) {
+                        logger?.log.message(`Type-aware mode enabled by ${currentRuleId} rule.`);
+                    }
                     if (cache && currentRuleLanguageServiceUsage === languageServiceUsage) {
                         cachedRules.set(currentRuleId, currentFixes);
                     }

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 | Config[]>;
+export declare function buildConfigFile(configFilePath: string, createHash?: (path: string) => string, logger?: typeof import('@clack/prompts')): Promise<Config | Config[]>;

package/lib/build.js

@@ -2,7 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.buildConfigFile = buildConfigFile;
 const watch_1 = require("./watch");
-function buildConfigFile(configFilePath, createHash, logger) {
+function buildConfigFile(configFilePath, createHash, 
+// @ts-expect-error
+logger) {
     return new Promise((resolve, reject) => {
         (0, watch_1.watchConfigFile)(configFilePath, (config, result) => {
             if (config) {

package/lib/logger.d.ts

@@ -0,0 +1 @@
+export declare function startLoad(text: string): (endText: string) => void;

package/lib/logger.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startLoad = startLoad;
+const frames = ['-', '\\', '|', '/'];
+function startLoad(text) {
+    const start = Date.now();
+    let i = 0;
+    const loadingInterval = setInterval(() => {
+        process.stdout.write(`\r${frames[i++ % frames.length]} ${text}...`);
+    }, 100);
+    return (endText) => {
+        clearInterval(loadingInterval);
+        process.stdout.write(`\r${endText} in ${Date.now() - start}ms\n`);
+    };
+}
+//# sourceMappingURL=logger.js.map

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 | 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?: typeof import('@clack/prompts')): Promise<esbuild.BuildContext<{
     entryPoints: string[];
     bundle: true;
     sourcemap: true;

package/lib/watch.js

@@ -7,14 +7,14 @@ 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, logger = console) {
-    let start;
+async function watchConfigFile(configFilePath, onBuild, watch = true, createHash = btoa, 
+// @ts-expect-error
+logger) {
     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) => {
-        const t1 = Date.now() - start;
-        start = Date.now();
         let config;
         for (const error of [
             ...result.errors,
@@ -27,11 +27,17 @@ async function watchConfigFile(configFilePath, onBuild, watch = true, createHash
                 error.id = 'config-build-error';
             }
         }
+        const buildResultText = 'Built ' + configFileDisplayPath + ' in ' + (Date.now() - buildStart) + 'ms';
+        configBuildingSpinner?.message(buildResultText);
         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) {
@@ -67,10 +73,11 @@ async function watchConfigFile(configFilePath, onBuild, watch = true, createHash
                 }
             }
         }
-        const t2 = Date.now() - start;
-        logger.log(`Built ${_path.relative(process.cwd(), configFilePath)} in ${t1}ms, loaded ${config ? 'successfully' : 'with errors'} in ${t2}ms`);
         onBuild(config, result);
     };
+    let buildStart;
+    const configBuildingSpinner = logger?.spinner();
+    configBuildingSpinner?.start('Building ' + configFileDisplayPath);
     const ctx = await esbuild.context({
         entryPoints: [configFilePath],
         bundle: true,
@@ -82,25 +89,33 @@ async function watchConfigFile(configFilePath, onBuild, watch = true, createHash
                 name: 'tsslint',
                 setup(build) {
                     build.onStart(() => {
-                        start = Date.now();
+                        buildStart = Date.now();
                     });
-                    build.onResolve({ filter: /^https?:\/\// }, async ({ path: url }) => {
-                        const cachePath = _path.join(outDir, url.split('://')[0], ...url.split('://')[1].split('/'));
+                    build.onResolve({ filter: /^https?:\/\// }, async ({ path: importUrl }) => {
+                        const cachePath = _path.join(outDir, importUrl.split('://')[0], ...importUrl.split('://')[1].split('/'));
                         if (!fs.existsSync(cachePath)) {
-                            console.time('Download ' + url);
-                            const response = await fetch(url);
+                            configBuildingSpinner?.message('Downloading ' + importUrl);
+                            const response = await fetch(importUrl);
+                            configBuildingSpinner?.message('Building ' + configFileDisplayPath);
                             if (!response.ok) {
-                                throw new Error(`Failed to load ${url}`);
+                                throw new Error(`Failed to load ${importUrl}`);
                             }
-                            console.timeEnd('Download ' + url);
                             const text = await response.text();
                             fs.mkdirSync(_path.dirname(cachePath), { recursive: true });
                             fs.writeFileSync(cachePath, text, 'utf8');
                         }
-                        return {
-                            path: cachePath,
-                            external: !isTsFile(cachePath),
-                        };
+                        if (isTsFile(cachePath)) {
+                            return {
+                                path: cachePath,
+                                external: false,
+                            };
+                        }
+                        else {
+                            return {
+                                path: url.pathToFileURL(cachePath).toString(),
+                                external: true,
+                            };
+                        }
                     });
                     build.onResolve({ filter: /.*/ }, ({ path, resolveDir }) => {
                         if (!isTsFile(path)) {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@tsslint/core",
-	"version": "1.3.1",
+	"version": "1.3.3",
 	"license": "MIT",
 	"files": [
 		"**/*.js",
@@ -12,11 +12,17 @@
 		"directory": "packages/core"
 	},
 	"dependencies": {
-		"@tsslint/types": "1.3.1",
+		"@tsslint/types": "1.3.3",
 		"error-stack-parser": "^2.1.4",
 		"esbuild": ">=0.17.0",
 		"minimatch": "^10.0.1",
 		"source-map-support": "^0.5.21"
 	},
-	"gitHead": "ddc73232699ecd7b4e4bfe5c9b511254c5926986"
+	"devDependencies": {
+		"@clack/prompts": "^0.8.2"
+	},
+	"scripts": {
+		"postinstall": "node scripts/cleanCache.js"
+	},
+	"gitHead": "0603ce9e9688c96478f96522b56335830390f740"
 }

package/scripts/cleanCache.js

@@ -0,0 +1,20 @@
+const fs = require('fs');
+const path = require('path');
+
+let dir = __dirname;
+
+while (true) {
+	const cachePath = path.join(dir, 'node_modules', '.tsslint');
+	if (fs.existsSync(cachePath)) {
+		console.log(`Removing ${cachePath}`);
+		fs.rmSync(cachePath, { recursive: true });
+		break;
+	}
+
+	const parentDir = path.resolve(dir, '..');
+	if (parentDir === dir) {
+		break;
+	}
+
+	dir = parentDir;
+}