@ttsc/lint 0.13.0 → 0.14.0-dev.20250530.1

package/lib/structures/rules/ITtscLintUnicornRules.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=ITtscLintUnicornRules.js.map

package/lib/structures/rules/ITtscLintUnicornRules.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ITtscLintUnicornRules.js","sourceRoot":"","sources":["../../../src/structures/rules/ITtscLintUnicornRules.ts"],"names":[],"mappings":""}

package/lib/structures/rules/ITtscLintVitestRules.d.ts

@@ -0,0 +1,133 @@
+import type { TtscLintRuleSetting } from "../TtscLintRuleSetting";
+/**
+ * Vitest test source rules from `@vitest/eslint-plugin`.
+ *
+ * Vitest reuses much of Jest's testing surface but ships its own runner and
+ * configuration. These rules mirror the ergonomic subset of
+ * `eslint-plugin-jest` adapted for Vitest semantics — focused tests, identical
+ * titles, conditional logic, valid `expect` shape.
+ *
+ * @reference https://github.com/vitest-dev/eslint-plugin-vitest
+ */
+export interface ITtscLintVitestRules {
+    /**
+     * Require every Vitest test body to contain at least one `expect(...)` call.
+     * A test with no assertions still passes, giving a false-positive signal.
+     *
+     * @reference https://github.com/vitest-dev/eslint-plugin-vitest/blob/main/docs/rules/expect-expect.md
+     */
+    "vitest/expect-expect"?: TtscLintRuleSetting;
+    /**
+     * Reject `expect(...)` calls under `if`/`try`/`catch` or other conditional
+     * branches in Vitest tests.
+     *
+     * A branch that never runs turns the assertion into a silent no-op rather
+     * than a failure.
+     *
+     * @reference https://github.com/vitest-dev/eslint-plugin-vitest/blob/main/docs/rules/no-conditional-expect.md
+     */
+    "vitest/no-conditional-expect"?: TtscLintRuleSetting;
+    /**
+     * Reject `test(...)`/`it(...)` declarations inside loops or `if` branches.
+     *
+     * Vitest collects tests at module load, so a conditional declaration produces
+     * a different suite shape than the file appears to describe.
+     *
+     * @reference https://github.com/vitest-dev/eslint-plugin-vitest/blob/main/docs/rules/no-conditional-tests.md
+     */
+    "vitest/no-conditional-tests"?: TtscLintRuleSetting;
+    /**
+     * Reject `test.skip`, `it.skip`, `describe.skip`, and `.todo` variants.
+     *
+     * Disabled tests rot in place and quietly drop coverage for the feature they
+     * were meant to pin.
+     *
+     * @reference https://github.com/vitest-dev/eslint-plugin-vitest/blob/main/docs/rules/no-disabled-tests.md
+     */
+    "vitest/no-disabled-tests"?: TtscLintRuleSetting;
+    /**
+     * Reject `done` callback parameters in Vitest tests and lifecycle hooks.
+     *
+     * The callback style predates async/await and makes failure propagation easy
+     * to miss; return a Promise or mark the body `async` instead.
+     *
+     * @reference https://github.com/vitest-dev/eslint-plugin-vitest/blob/main/docs/rules/no-done-callback.md
+     */
+    "vitest/no-done-callback"?: TtscLintRuleSetting;
+    /**
+     * Reject `test.only`, `it.only`, and `describe.only`.
+     *
+     * A focused suite silently skips the rest of the file, so a stray `.only`
+     * left from debugging hides every other test in CI.
+     *
+     * @reference https://github.com/vitest-dev/eslint-plugin-vitest/blob/main/docs/rules/no-focused-tests.md
+     */
+    "vitest/no-focused-tests"?: TtscLintRuleSetting;
+    /**
+     * Reject duplicate Vitest test or `describe` titles within the same suite
+     * scope.
+     *
+     * The runner cannot disambiguate two siblings with identical names in its
+     * error output or filter flags.
+     *
+     * @reference https://github.com/vitest-dev/eslint-plugin-vitest/blob/main/docs/rules/no-identical-title.md
+     */
+    "vitest/no-identical-title"?: TtscLintRuleSetting;
+    /**
+     * Reject `expect(...)` calls outside Vitest tests and hooks.
+     *
+     * Top-level assertions execute at module load before any test starts, so
+     * failures never attach to a named case.
+     *
+     * @reference https://github.com/vitest-dev/eslint-plugin-vitest/blob/main/docs/rules/no-standalone-expect.md
+     */
+    "vitest/no-standalone-expect"?: TtscLintRuleSetting;
+    /**
+     * Reject `return` statements that return non-Promise values from a Vitest
+     * test callback.
+     *
+     * The runner ignores the value and following code is dead, which usually
+     * masks a missing `await` or stray early-exit.
+     *
+     * @reference https://github.com/vitest-dev/eslint-plugin-vitest/blob/main/docs/rules/no-test-return-statement.md
+     */
+    "vitest/no-test-return-statement"?: TtscLintRuleSetting;
+    /**
+     * Prefer `expect(value).toHaveLength(n)` over asserting on `value.length`
+     * with `toBe`.
+     *
+     * The dedicated matcher reports the actual length on failure instead of a
+     * bare number mismatch.
+     *
+     * @reference https://github.com/vitest-dev/eslint-plugin-vitest/blob/main/docs/rules/prefer-to-have-length.md
+     */
+    "vitest/prefer-to-have-length"?: TtscLintRuleSetting;
+    /**
+     * Validate the shape of Vitest `describe` callbacks.
+     *
+     * The callback must be synchronous and take no arguments — the runner ignores
+     * returned Promises and `done`-style parameters at the describe level.
+     *
+     * @reference https://github.com/vitest-dev/eslint-plugin-vitest/blob/main/docs/rules/valid-describe-callback.md
+     */
+    "vitest/valid-describe-callback"?: TtscLintRuleSetting;
+    /**
+     * Validate `expect(...)` arity and matcher chaining: exactly one argument,
+     * terminated by a matcher call, and async matchers properly awaited.
+     *
+     * Malformed expects either throw at runtime or pass without asserting
+     * anything.
+     *
+     * @reference https://github.com/vitest-dev/eslint-plugin-vitest/blob/main/docs/rules/valid-expect.md
+     */
+    "vitest/valid-expect"?: TtscLintRuleSetting;
+    /**
+     * Require non-empty static Vitest test and `describe` titles.
+     *
+     * Empty or dynamically-built titles produce unreadable failure output and
+     * break filter-by-name flags.
+     *
+     * @reference https://github.com/vitest-dev/eslint-plugin-vitest/blob/main/docs/rules/valid-title.md
+     */
+    "vitest/valid-title"?: TtscLintRuleSetting;
+}

package/lib/structures/rules/ITtscLintVitestRules.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=ITtscLintVitestRules.js.map

package/lib/structures/rules/ITtscLintVitestRules.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ITtscLintVitestRules.js","sourceRoot":"","sources":["../../../src/structures/rules/ITtscLintVitestRules.ts"],"names":[],"mappings":""}

package/lib/structures/rules/index.d.ts

@@ -0,0 +1,31 @@
+export * from "./ITtscLintBoundariesRuleOptions";
+export * from "./ITtscLintBoundariesRules";
+export * from "./ITtscLintContributorRules";
+export * from "./ITtscLintCoreRules";
+export * from "./ITtscLintCypressRuleOptions";
+export * from "./ITtscLintCypressRules";
+export * from "./ITtscLintFunctionalRuleOptions";
+export * from "./ITtscLintFunctionalRules";
+export * from "./ITtscLintJestRules";
+export * from "./ITtscLintJsdocRules";
+export * from "./ITtscLintJsxA11yRules";
+export * from "./ITtscLintNextjsRules";
+export * from "./ITtscLintPlaywrightRules";
+export * from "./ITtscLintPromiseRules";
+export * from "./ITtscLintReactPerfRuleOptions";
+export * from "./ITtscLintReactPerfRules";
+export * from "./ITtscLintReactRuleOptions";
+export * from "./ITtscLintReactRules";
+export * from "./ITtscLintRegexpRules";
+export * from "./ITtscLintRuleOptionsMap";
+export * from "./ITtscLintRules";
+export * from "./ITtscLintSecurityRules";
+export * from "./ITtscLintSolidRules";
+export * from "./ITtscLintStorybookRuleOptions";
+export * from "./ITtscLintStorybookRules";
+export * from "./ITtscLintTanstackQueryRules";
+export * from "./ITtscLintTestingLibraryRuleOptions";
+export * from "./ITtscLintTestingLibraryRules";
+export * from "./ITtscLintTypeScriptRules";
+export * from "./ITtscLintUnicornRules";
+export * from "./ITtscLintVitestRules";

package/lib/structures/rules/index.js

@@ -0,0 +1,48 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./ITtscLintBoundariesRuleOptions"), exports);
+__exportStar(require("./ITtscLintBoundariesRules"), exports);
+__exportStar(require("./ITtscLintContributorRules"), exports);
+__exportStar(require("./ITtscLintCoreRules"), exports);
+__exportStar(require("./ITtscLintCypressRuleOptions"), exports);
+__exportStar(require("./ITtscLintCypressRules"), exports);
+__exportStar(require("./ITtscLintFunctionalRuleOptions"), exports);
+__exportStar(require("./ITtscLintFunctionalRules"), exports);
+__exportStar(require("./ITtscLintJestRules"), exports);
+__exportStar(require("./ITtscLintJsdocRules"), exports);
+__exportStar(require("./ITtscLintJsxA11yRules"), exports);
+__exportStar(require("./ITtscLintNextjsRules"), exports);
+__exportStar(require("./ITtscLintPlaywrightRules"), exports);
+__exportStar(require("./ITtscLintPromiseRules"), exports);
+__exportStar(require("./ITtscLintReactPerfRuleOptions"), exports);
+__exportStar(require("./ITtscLintReactPerfRules"), exports);
+__exportStar(require("./ITtscLintReactRuleOptions"), exports);
+__exportStar(require("./ITtscLintReactRules"), exports);
+__exportStar(require("./ITtscLintRegexpRules"), exports);
+__exportStar(require("./ITtscLintRuleOptionsMap"), exports);
+__exportStar(require("./ITtscLintRules"), exports);
+__exportStar(require("./ITtscLintSecurityRules"), exports);
+__exportStar(require("./ITtscLintSolidRules"), exports);
+__exportStar(require("./ITtscLintStorybookRuleOptions"), exports);
+__exportStar(require("./ITtscLintStorybookRules"), exports);
+__exportStar(require("./ITtscLintTanstackQueryRules"), exports);
+__exportStar(require("./ITtscLintTestingLibraryRuleOptions"), exports);
+__exportStar(require("./ITtscLintTestingLibraryRules"), exports);
+__exportStar(require("./ITtscLintTypeScriptRules"), exports);
+__exportStar(require("./ITtscLintUnicornRules"), exports);
+__exportStar(require("./ITtscLintVitestRules"), exports);
+//# sourceMappingURL=index.js.map

package/lib/structures/rules/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/structures/rules/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,mEAAiD;AACjD,6DAA2C;AAC3C,8DAA4C;AAC5C,uDAAqC;AACrC,gEAA8C;AAC9C,0DAAwC;AACxC,mEAAiD;AACjD,6DAA2C;AAC3C,uDAAqC;AACrC,wDAAsC;AACtC,0DAAwC;AACxC,yDAAuC;AACvC,6DAA2C;AAC3C,0DAAwC;AACxC,kEAAgD;AAChD,4DAA0C;AAC1C,8DAA4C;AAC5C,wDAAsC;AACtC,yDAAuC;AACvC,4DAA0C;AAC1C,mDAAiC;AACjC,2DAAyC;AACzC,wDAAsC;AACtC,kEAAgD;AAChD,4DAA0C;AAC1C,gEAA8C;AAC9C,uEAAqD;AACrD,iEAA+C;AAC/C,6DAA2C;AAC3C,0DAAwC;AACxC,yDAAuC"}

package/linthost/ast_helpers.go

@@ -269,15 +269,40 @@ func stringLiteralText(node *shimast.Node) string {
 }
 
 // walkDescendants visits node and every child below it, depth-first.
+//
+// The naive recursive shape `node.ForEachChild(func(child) bool {
+// walkDescendants(child, visit); return false })` allocates one
+// closure per recursive call (the inner func captures `visit` and
+// the outer function reference), so a subtree of N nodes costs N
+// closure allocations. The struct walker below caches the
+// `ForEachChild` callback as a method value bound once to the
+// walker, dropping that cost to one allocation per `walkDescendants`
+// call regardless of subtree size.
 func walkDescendants(node *shimast.Node, visit func(*shimast.Node)) {
   if node == nil {
     return
   }
-  visit(node)
-  node.ForEachChild(func(child *shimast.Node) bool {
-    walkDescendants(child, visit)
-    return false
-  })
+  w := &descendantsWalker{visit: visit}
+  w.childCB = w.visitChild
+  w.walk(node)
+}
+
+type descendantsWalker struct {
+  visit   func(*shimast.Node)
+  childCB func(*shimast.Node) bool
+}
+
+func (w *descendantsWalker) walk(node *shimast.Node) {
+  if node == nil {
+    return
+  }
+  w.visit(node)
+  node.ForEachChild(w.childCB)
+}
+
+func (w *descendantsWalker) visitChild(child *shimast.Node) bool {
+  w.walk(child)
+  return false
 }
 
 // assignmentTargetNames collects the identifier names written by an

package/linthost/compile.go

@@ -21,6 +21,7 @@ import (
   "os"
   "path/filepath"
   "strings"
+  "time"
 
   shimast "github.com/microsoft/typescript-go/shim/ast"
   shimcompiler "github.com/microsoft/typescript-go/shim/compiler"
@@ -63,6 +64,8 @@ func RunTransform(args []string) int {
   singleThreaded := fs.Bool("singleThreaded", false, "run TypeScript-Go single-threaded")
   checkers := fs.Int("checkers", 0, "type-checker pool size (0 = TypeScript-Go default)")
   tsgoArgsRaw := fs.String("tsgo-args", "", "JSON array of forwarded tsgo CLI flags")
+  _ = fs.Bool("diagnostics", false, "print @ttsc/lint diagnostics timing")
+  _ = fs.Bool("extendedDiagnostics", false, "print @ttsc/lint diagnostics timing")
   if err := fs.Parse(filterKnownFlags(args, LintFlagAllowList)); err != nil {
     return 2
   }
@@ -171,6 +174,7 @@ type subcommandOpts struct {
   noEmit         bool
   quiet          bool
   verbose        bool
+  diagnostics    bool
   outDir         string
   singleThreaded bool
   checkers       int
@@ -190,6 +194,8 @@ func parseSubcommandFlags(name string, args []string) (*subcommandOpts, error) {
   noEmit := fs.Bool("noEmit", false, "")
   quiet := fs.Bool("quiet", false, "")
   verbose := fs.Bool("verbose", false, "")
+  diagnostics := fs.Bool("diagnostics", false, "")
+  extendedDiagnostics := fs.Bool("extendedDiagnostics", false, "")
   outDir := fs.String("outDir", "", "")
   singleThreaded := fs.Bool("singleThreaded", false, "")
   checkers := fs.Int("checkers", 0, "")
@@ -216,6 +222,7 @@ func parseSubcommandFlags(name string, args []string) (*subcommandOpts, error) {
     noEmit:         *noEmit,
     quiet:          *quiet,
     verbose:        *verbose,
+    diagnostics:    *diagnostics || *extendedDiagnostics,
     outDir:         *outDir,
     singleThreaded: *singleThreaded,
     checkers:       *checkers,
@@ -268,11 +275,12 @@ func runProject(opts *subcommandOpts) int {
   }
   defer prog.close()
 
-  astDiags, lintDiags, err := collectDiagnostics(prog, engine)
+  astDiags, lintDiags, diagnosticsTiming, err := collectDiagnosticsTimed(prog, engine)
   if err != nil {
     fmt.Fprintln(os.Stderr, err)
     return 2
   }
+  printLintDiagnosticsTiming(os.Stdout, opts.diagnostics, diagnosticsTiming)
   warnUnknownRules(os.Stderr, engine.UnknownRules())
   if errCount := shimdw.FormatMixedDiagnostics(os.Stderr, astDiags, lintDiags, opts.cwd); errCount > 0 {
     return 2
@@ -373,9 +381,21 @@ func filterKnownFlags(args []string, known map[string]bool) []string {
 // engine's findings. The renderer takes the two slices and walks them in
 // source order, so we don't need to interleave here.
 func collectDiagnostics(prog *program, engine *Engine) ([]*shimast.Diagnostic, []*shimdw.LintDiagnostic, error) {
+  astDiags, lintDiags, _, err := collectDiagnosticsTimed(prog, engine)
+  return astDiags, lintDiags, err
+}
+
+type lintDiagnosticsTiming struct {
+  lint time.Duration
+}
+
+func collectDiagnosticsTimed(prog *program, engine *Engine) ([]*shimast.Diagnostic, []*shimdw.LintDiagnostic, lintDiagnosticsTiming, error) {
+  timing := lintDiagnosticsTiming{}
   astDiags := prog.programDiagnostics()
   files := prog.userSourceFiles()
+  lintStarted := time.Now()
   findings := engine.Run(files, prog.checker)
+  timing.lint = time.Since(lintStarted)
   nativeDiags := make([]*shimdw.LintDiagnostic, 0, len(findings))
   for _, finding := range findings {
     category := shimdw.LintCategoryError
@@ -391,7 +411,18 @@ func collectDiagnostics(prog *program, engine *Engine) ([]*shimast.Diagnostic, [
       fmt.Sprintf("[%s] %s", finding.Rule, finding.Message),
     ))
   }
-  return astDiags, nativeDiags, nil
+  return astDiags, nativeDiags, timing, nil
+}
+
+func printLintDiagnosticsTiming(w io.Writer, enabled bool, timing lintDiagnosticsTiming) {
+  if !enabled {
+    return
+  }
+  fmt.Fprintf(w, "@ttsc/lint time: %s\n", formatTimingSeconds(timing.lint))
+}
+
+func formatTimingSeconds(duration time.Duration) string {
+  return fmt.Sprintf("%.3fs", duration.Seconds())
 }
 
 // RuleCode hashes a rule name into a stable, positive int32 so the