@tsslint/config 3.0.4 → 3.1.1

package/README.md

@@ -0,0 +1,32 @@
+# @tsslint/config
+
+Public API for `tsslint.config.ts`: `defineConfig`, `defineRule`, `definePlugin`, bundled plugin factories (`createIgnorePlugin`, `createCategoryPlugin`, `createDiagnosticsPlugin`), and importers for ESLint / TSLint / TSL rules.
+
+## Usage
+
+```bash
+npm install @tsslint/config --save-dev
+```
+
+```ts
+import { defineConfig } from '@tsslint/config';
+
+export default defineConfig({
+  rules: {
+    'no-debugger': ({ typescript: ts, file, report }) => {
+      ts.forEachChild(file, function visit(node) {
+        if (node.kind === ts.SyntaxKind.DebuggerStatement) {
+          report('Debugger statement is not allowed.', node.getStart(file), node.getEnd());
+        }
+        ts.forEachChild(node, visit);
+      });
+    },
+  },
+});
+```
+
+`defineRule` / `definePlugin` are available for authoring rules or plugins in their own files, where the context type can't be inferred from the surrounding config.
+
+The package also ships a `tsslint-docgen` binary that generates JSDoc for imported ESLint/TSLint rules so they autocomplete in your config.
+
+See the [root README](../../README.md) for rule authoring, ESLint/TSLint/TSL interop, plugins, and caching.

package/lib/eslint.js

@@ -54,6 +54,96 @@ const loader = async (moduleName) => {
     }
     return mod;
 };
+// Per-plugin "where do individual rule files live" cache. Filled the first
+// time we successfully load a rule from that plugin, then reused for every
+// subsequent rule from the same plugin so we never have to require the
+// whole plugin (which on `@typescript-eslint/eslint-plugin` is ~400 ms
+// cold start to load all ~150 rules eagerly).
+//
+// `null` means "we tried to detect a per-rule layout and couldn't — fall
+// back to whole-plugin require for any rule from this plugin".
+const pluginRuleLoaders = new Map();
+// Common per-rule directory layouts in published ESLint plugins.
+//   `dist/rules/<name>.js`      — @typescript-eslint, eslint-plugin-jsdoc (newer)
+//   `lib/rules/<name>.js`       — eslint-plugin-react / import / vue / n / jsx-a11y
+//   `rules/<name>.js`           — eslint-plugin-unicorn / promise
+//   `build/rules/<name>.js`     — some Babel-built plugins
+//   `src/rules/<name>.js`       — published-from-source plugins (rare)
+//
+// Each candidate is probed with the FIRST rule we're asked to load. The
+// directory that has that rule's file wins; remember the layout so later
+// rules go straight to disk by absolute path.
+const RULE_DIR_CANDIDATES = ['dist/rules', 'lib/rules', 'rules', 'build/rules', 'src/rules'];
+const RULE_FILE_EXTS = ['.js', '.cjs'];
+function detectRuleLoader(pluginName, probeRuleName) {
+    let pkgRoot;
+    try {
+        pkgRoot = path.dirname(require.resolve(`${pluginName}/package.json`));
+    }
+    catch {
+        return null;
+    }
+    for (const dir of RULE_DIR_CANDIDATES) {
+        for (const ext of RULE_FILE_EXTS) {
+            const probePath = path.join(pkgRoot, dir, probeRuleName + ext);
+            if (!fs.existsSync(probePath))
+                continue;
+            // Lock in this dir + ext for every subsequent rule from this plugin.
+            // Absolute-path `require()` bypasses the package's `exports` field
+            // (which in @typescript-eslint blocks `dist/rules/<name>` access),
+            // so this works even when the plugin doesn't expose individual
+            // rules as a public subpath.
+            //
+            // Pre-warm the plugin's shared dependency tree behind a
+            // stable, plugin-named profile frame. Without this, the
+            // first rule we happen to load gets blamed for ~150–250 ms
+            // of `@typescript-eslint/utils` + `scope-manager` +
+            // `typescript-estree` etc. transitive load — and which rule
+            // that is depends on the user's config-object key order.
+            // The pre-warm gives that cost a deterministic attribution
+            // (`<pluginName>:init` shows up in the flame graph) and
+            // leaves every subsequent rule frame as pure rule-body
+            // load time.
+            //
+            // `//# sourceURL=` directive lets Chrome DevTools surface
+            // these `new Function`-derived frames in flame graphs /
+            // Bottom-Up / search; without it the SharedFunctionInfo
+            // has an empty url and DevTools hides the frame as native.
+            const initKey = JSON.stringify(pluginName + ':init');
+            const probeAbs = path.join(pkgRoot, dir, probeRuleName + ext);
+            new Function('warm', `({ ${initKey}: () => warm() })[${initKey}]();\n//# sourceURL=tsslint-rule-loader/${pluginName}/init.js`)(() => {
+                try {
+                    require(probeAbs);
+                }
+                catch { }
+            });
+            // Per-rule named thunk. NamedEvaluation on a computed
+            // property key (`{ [name]: () => ... }`) sets
+            // `Function.prototype.name` at runtime — visible to stack
+            // traces, but V8's CPU profile uses the parse-time-inferred
+            // SharedFunctionInfo name and ignores runtime renames. To
+            // get a parse-time literal name we compile per-thunk source
+            // with `new Function`, baking the rule name in as a string
+            // literal. Same trick ESLint core's `LazyLoadingRuleMap`
+            // achieves with static-keyed object literals.
+            return ruleName => {
+                const filePath = path.join(pkgRoot, dir, ruleName + ext);
+                const key = JSON.stringify(ruleName);
+                const thunk = new Function('requireFn', `return ({ ${key}: () => requireFn() })[${key}];\n//# sourceURL=tsslint-rule-loader/${pluginName}/${ruleName}.js`)(() => {
+                    try {
+                        const m = require(filePath);
+                        return (m && 'default' in m ? m.default : m);
+                    }
+                    catch {
+                        return undefined;
+                    }
+                });
+                return thunk();
+            };
+        }
+    }
+    return null;
+}
 /**
  * Converts an ESLint rules configuration to TSSLint rules.
  *
@@ -126,6 +216,25 @@ async function loadRuleByKey(rule) {
 }
 async function loadRule(pluginName, ruleName) {
     if (pluginName) {
+        // Try per-rule lazy load first — saves loading the whole plugin's
+        // ~all-rules-eager bundle. On a 30-rule typescript-eslint config
+        // this saves ~150 ms cold start vs requiring the whole plugin.
+        let lazy = pluginRuleLoaders.get(pluginName);
+        if (lazy === undefined) {
+            lazy = detectRuleLoader(pluginName, ruleName);
+            pluginRuleLoaders.set(pluginName, lazy);
+        }
+        if (lazy) {
+            const r = lazy(ruleName);
+            if (r)
+                return r;
+            // Layout was detected but this specific rule's file doesn't
+            // exist there (rule renamed / moved / lives under a sub-path).
+            // Fall through to whole-plugin load below.
+        }
+        // Fallback: ESM-only plugins, plugins with no recognisable layout,
+        // or rules whose file doesn't sit at `<dir>/<name>.js`. Pay the
+        // eager cost once per plugin.
         plugins[pluginName] ??= loader(pluginName);
         const plugin = await plugins[pluginName];
         return plugin?.rules[ruleName];
@@ -134,7 +243,7 @@ async function loadRule(pluginName, ruleName) {
     while (true) {
         const rulePath = path.join(dir, 'node_modules', 'eslint', 'lib', 'rules', `${ruleName}.js`);
         if (fs.existsSync(rulePath)) {
-            return loader(rulePath);
+            return require(rulePath);
         }
         const parentDir = path.resolve(dir, '..');
         if (parentDir === dir) {

package/lib/plugins/ignore.js

@@ -2,6 +2,28 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.create = create;
 const ts_api_utils_1 = require("ts-api-utils");
+// `forEachComment` walks every token of the source file; if multiple ignore
+// plugins are configured (one per directive form) we'd walk the same file
+// 3+ times per lint pass. Cache the comment list once per ts.SourceFile so
+// every plugin shares a single sweep. The WeakMap drops entries when the
+// SourceFile is GC'd.
+const sharedFileComments = new WeakMap();
+function getFileComments(file) {
+    let comments = sharedFileComments.get(file);
+    if (!comments) {
+        comments = [];
+        (0, ts_api_utils_1.forEachComment)(file, (fullText, { pos, end }) => {
+            const start = pos + 2; // strip leading `//` or `/*`
+            comments.push({
+                pos: start,
+                end,
+                text: fullText.substring(start, end),
+            });
+        });
+        sharedFileComments.set(file, comments);
+    }
+    return comments;
+}
 function create(cmdOption, reportsUnusedComments) {
     const mode = typeof cmdOption === 'string' ? 'singleLine' : 'multiLine';
     const [cmd, endCmd] = Array.isArray(cmdOption) ? cmdOption : [cmdOption, undefined];
@@ -113,14 +135,10 @@ function create(cmdOption, reportsUnusedComments) {
                     return results;
                 }
                 const comments = new Map();
-                const logs = [];
-                (0, ts_api_utils_1.forEachComment)(file, (fullText, { pos, end }) => {
-                    pos += 2; // Trim the // or /* characters
-                    const commentText = fullText.substring(pos, end);
-                    logs.push(commentText);
-                    const startComment = commentText.match(reg);
+                for (const c of getFileComments(file)) {
+                    const startComment = c.text.match(reg);
                     if (startComment?.index !== undefined) {
-                        const index = startComment.index + pos;
+                        const index = startComment.index + c.pos;
                         const ruleId = startComment.groups?.ruleId;
                         if (!comments.has(ruleId)) {
                             comments.set(ruleId, []);
@@ -143,9 +161,9 @@ function create(cmdOption, reportsUnusedComments) {
                         });
                     }
                     else if (endReg) {
-                        const endComment = commentText.match(endReg);
+                        const endComment = c.text.match(endReg);
                         if (endComment?.index !== undefined) {
-                            const index = endComment.index + pos;
+                            const index = endComment.index + c.pos;
                             const prevLine = file.getLineAndCharacterOfPosition(index).line;
                             const ruleId = endComment.groups?.ruleId;
                             const disabledLines = comments.get(ruleId);
@@ -154,7 +172,7 @@ function create(cmdOption, reportsUnusedComments) {
                             }
                         }
                     }
-                });
+                }
                 let reportedRules = reportedRulesOfFile.get(file.fileName);
                 if (!reportedRules) {
                     reportedRules = [];

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@tsslint/config",
-	"version": "3.0.4",
+	"version": "3.1.1",
 	"license": "MIT",
 	"engines": {
 		"node": ">=22.6.0"
@@ -18,12 +18,12 @@
 		"directory": "packages/config"
 	},
 	"dependencies": {
-		"@tsslint/types": "3.0.4",
+		"@tsslint/types": "3.1.1",
 		"minimatch": "^10.0.1",
 		"ts-api-utils": "^2.0.0"
 	},
 	"devDependencies": {
-		"@tsslint/compat-eslint": "3.0.4",
+		"@tsslint/compat-eslint": "3.1.1",
 		"tslint": "^6.1.3"
 	},
 	"peerDependencies": {
@@ -38,5 +38,5 @@
 			"optional": true
 		}
 	},
-	"gitHead": "6b48fe1a7b0f563f9d6cb48e07383824a29c011a"
+	"gitHead": "fc3aee61fa769d7475897ac91ebfcc929c7e1336"
 }