@ttsc/lint 0.8.0-dev.20260506 → 0.8.1

package/README.md

@@ -112,20 +112,88 @@ You can also keep the rules in a standalone file and reference it from `tsconfig
 
 ```ts
 // ttsc-lint.config.ts
+import type { TtscLintConfig } from "@ttsc/lint/config";
+
 export default {
   "no-var": "error",
   "prefer-const": "error",
   "no-explicit-any": "warning",
   "no-console": "off",
-};
+} satisfies TtscLintConfig;
 ```
 
 The `config` field accepts:
 
 - An inline object (shown earlier), **or** a path to a file ending in `.json`, `.js`, `.cjs`, `.mjs`, `.ts`, `.cts`, or `.mts`.
 - For JS/TS configs: a `default` export, a named `config` export, a direct module export, or a function that returns the object.
+- If `config` is omitted, `@ttsc/lint` discovers the nearest `eslint.config.js`, `eslint.config.mjs`, `eslint.config.cjs`, `eslint.config.ts`, `eslint.config.mts`, or `eslint.config.cts` from the owning `tsconfig.json` directory upward.
+- Inline objects use the standard `@ttsc/lint` native rule map shape.
+- Standalone config files may additionally export ESLint flat-config-style objects or arrays. `@ttsc/lint` lowers their `basePath`, `files`, `ignores`, object/array `extends`, and `rules` fields into native per-file rule maps, accepts ESLint severity tuples, and maps `@typescript-eslint/<rule>` keys to native rule names when a matching native rule exists.
 - Relative paths resolve from the directory of the owning `tsconfig.json`.
 
+For example, a flat-config-style file can enable native `@ttsc/lint` rules with
+ESLint or `@typescript-eslint/*` keys:
+
+```ts
+// eslint.config.ts
+import type { Linter } from "eslint";
+
+const config = [
+  {
+    rules: {
+      "@typescript-eslint/no-explicit-any": "error",
+      "@typescript-eslint/consistent-type-imports": [
+        "warning",
+        { fixStyle: "inline-type-imports" },
+      ],
+      "no-console": "off",
+    },
+  },
+] satisfies Linter.Config[];
+
+export default config;
+```
+
+Config factories can be used when they return a resolved flat config object or
+array. Current `typescript-eslint` versions prefer ESLint's `defineConfig(...)`;
+existing configs that still use `typescript-eslint`'s `config(...)` are readable
+when they export the resolved object/array shape:
+
+```ts
+// eslint.config.ts
+import tseslint, { type ConfigArray } from "typescript-eslint";
+
+const config = tseslint.config({
+  extends: [tseslint.configs.recommended],
+  rules: {
+    "@typescript-eslint/no-explicit-any": "error",
+  },
+}) satisfies ConfigArray;
+
+export default config;
+```
+
+When a project has `eslint` installed and the external config is an
+`eslint.config.*` file, or the config uses runtime-only fields such as `plugins`,
+`languageOptions`, `processor`, `settings`, or string `extends`, `@ttsc/lint`
+delegates diagnostics to the installed ESLint runtime and forwards its rule ids,
+severities, messages, and locations. This is the path that runs external
+RuleModules such as `@typescript-eslint/no-floating-promises`; typed
+typescript-eslint rules work when your ESLint config supplies the usual parser
+and `parserOptions.project` / `projectService` settings.
+
+When ESLint is not installed and the config can be represented as native rules,
+`@ttsc/lint` falls back to the lowered native rule map. That fallback supports
+`files`, `ignores`, `basePath`, object/array `extends`, `rules`, severity tuples,
+and `@typescript-eslint/` or `typescript-eslint/` rule prefixes. Runtime-only
+features such as `plugins`, `languageOptions`, `processor`, `settings`,
+`linterOptions`, or string `extends` require ESLint to be installed.
+
+Inline disable comments are respected in both paths. Use the ESLint forms
+`eslint-disable-next-line`, `eslint-disable-line`, `eslint-disable`, and
+`eslint-enable`; the native engine also accepts the `lint-*` aliases for the
+same directives.
+
 ## Plugin order
 
 `@ttsc/lint` must be the first plugin in `compilerOptions.plugins`.
@@ -153,7 +221,9 @@ It inspects the source you wrote, so transform plugins such as `@ttsc/banner`, `
 
 ## Scope
 
-Diagnostic-only today: no autofix, no recommended preset, no custom rule loading, and no cross-file lint rules.
+Diagnostic-only today: no autofix and no bundled recommended preset. The native
+engine does not load custom Go rules; external ESLint RuleModules run through
+the installed ESLint runtime path described above.
 
 ## Rules
 

package/lib/config.d.ts

@@ -0,0 +1,3 @@
+export type { TtscLintConfig } from "./structures/TtscLintConfig";
+export type { TtscLintRule } from "./structures/TtscLintRule";
+export type { TtscLintSeverity } from "./structures/TtscLintSeverity";

package/lib/config.js

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

package/lib/config.js.map

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

package/lib/structures/ITtscLintPluginConfig.d.ts

@@ -3,10 +3,11 @@ import type { TtscLintConfig } from "./TtscLintConfig";
 /** `compilerOptions.plugins[]` entry shape consumed by `@ttsc/lint`. */
 export interface ITtscLintPluginConfig extends ITtscProjectPluginConfig {
     /**
-     * Inline rule map or path to a JSON config file.
+     * Inline rule map or path to a standalone lint config file.
      *
      * Inline maps are passed to the native sidecar through `--plugins-json`.
-     * String values are resolved by the sidecar from the project root.
+     * String values are resolved by the sidecar from the owning tsconfig
+     * directory and may point at JSON, JavaScript, or TypeScript config files.
      */
     config?: string | TtscLintConfig;
 }

package/lib/structures/TtscLintConfig.d.ts

@@ -3,9 +3,8 @@ import type { TtscLintSeverity } from "./TtscLintSeverity";
 /**
  * Inline rule map accepted by the `@ttsc/lint` tsconfig plugin entry.
  *
- * Each property key is a native lint rule name. Omitted rules use the sidecar's
- * default severity, while present rules override that severity for the current
- * project.
+ * Each property key is a native lint rule name. Omitted rules are disabled,
+ * while present rules enable or disable that rule for the current project.
  */
 export type TtscLintConfig = {
     [P in TtscLintRule]?: TtscLintSeverity;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ttsc/lint",
-  "version": "0.8.0-dev.20260506",
+  "version": "0.8.1",
   "description": "Reference ttsc plugin: ESLint-style lint rules hosted in the same Program/Checker as the type-check pass.",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",
@@ -9,6 +9,10 @@
       "types": "./lib/index.d.ts",
       "default": "./lib/index.js"
     },
+    "./config": {
+      "types": "./lib/config.d.ts",
+      "default": "./lib/config.js"
+    },
     "./package.json": "./package.json"
   },
   "keywords": [
@@ -22,15 +26,14 @@
     "README.md",
     "lib",
     "src",
-    "tsconfig.json",
     "go.mod",
     "plugin"
   ],
   "devDependencies": {
-    "@typescript/native-preview": "7.0.0-dev.20260504.1",
+    "@typescript/native-preview": "7.0.0-dev.20260506.1",
     "@types/node": "^25.3.0",
     "rimraf": "^6.1.2",
-    "ttsc": "0.8.0-dev.20260506"
+    "ttsc": "0.8.1"
   },
   "repository": {
     "type": "git",
@@ -43,7 +46,7 @@
   },
   "homepage": "https://github.com/samchon/ttsc/tree/master/packages/lint#readme",
   "scripts": {
-    "build": "rimraf lib && tsgo -p tsconfig.json",
+    "build": "rimraf lib && tsgo",
     "test": "pnpm run build && pnpm --dir ../../tests/lint start"
   }
 }

package/plugin/compile.go

@@ -95,10 +95,16 @@ func RunTransform(args []string) int {
     fmt.Fprintln(os.Stderr, err)
     return 2
   }
-  engine := NewEngine(rules)
-  warnUnknownRules(os.Stderr, engine.UnknownRules())
+  engine := NewEngineWithResolver(rules)
 
-  astDiags, lintDiags := collectDiagnostics(prog, engine)
+  astDiags, lintDiags, externalRan, err := collectDiagnostics(prog, engine)
+  if err != nil {
+    fmt.Fprintln(os.Stderr, err)
+    return 2
+  }
+  if !externalRan {
+    warnUnknownRules(os.Stderr, engine.UnknownRules())
+  }
   if errors := shimdw.FormatMixedDiagnostics(os.Stderr, astDiags, lintDiags, resolvedCwd); errors > 0 {
     return 2
   }
@@ -225,10 +231,16 @@ func runProject(opts *subcommandOpts) int {
     fmt.Fprintln(os.Stderr, err)
     return 2
   }
-  engine := NewEngine(rules)
-  warnUnknownRules(os.Stderr, engine.UnknownRules())
+  engine := NewEngineWithResolver(rules)
 
-  astDiags, lintDiags := collectDiagnostics(prog, engine)
+  astDiags, lintDiags, externalRan, err := collectDiagnostics(prog, engine)
+  if err != nil {
+    fmt.Fprintln(os.Stderr, err)
+    return 2
+  }
+  if !externalRan {
+    warnUnknownRules(os.Stderr, engine.UnknownRules())
+  }
   if errCount := shimdw.FormatMixedDiagnostics(os.Stderr, astDiags, lintDiags, opts.cwd); errCount > 0 {
     return 2
   }
@@ -261,7 +273,7 @@ func runProject(opts *subcommandOpts) int {
   return 0
 }
 
-func loadRules(pluginsJSON, cwd, tsconfigPath string) (RuleConfig, error) {
+func loadRules(pluginsJSON, cwd, tsconfigPath string) (RuleResolver, error) {
   entries, err := ParsePlugins(pluginsJSON)
   if err != nil {
     return nil, err
@@ -273,7 +285,7 @@ func loadRules(pluginsJSON, cwd, tsconfigPath string) (RuleConfig, error) {
   if entry == nil {
     return RuleConfig{}, nil
   }
-  return LoadRuleConfig(entry, cwd, tsconfigPath)
+  return LoadConfigResolver(entry, cwd, tsconfigPath)
 }
 
 func warnUnknownRules(w io.Writer, unknown []string) {
@@ -314,9 +326,14 @@ func filterKnownFlags(args []string, known map[string]bool) []string {
 // collectDiagnostics merges tsgo typecheck diagnostics with the lint
 // 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) {
+func collectDiagnostics(prog *program, engine *Engine) ([]*shimast.Diagnostic, []*shimdw.LintDiagnostic, bool, error) {
   astDiags := prog.programDiagnostics()
   files := prog.userSourceFiles()
+  if externalDiags, ran, err := runExternalESLintDiagnostics(engine.config, prog.cwd, files); err != nil {
+    return nil, nil, false, err
+  } else if ran {
+    return astDiags, externalDiags, true, nil
+  }
   findings := engine.Run(files, prog.checker)
   lintDiags := make([]*shimdw.LintDiagnostic, 0, len(findings))
   for _, finding := range findings {
@@ -333,7 +350,7 @@ func collectDiagnostics(prog *program, engine *Engine) ([]*shimast.Diagnostic, [
       fmt.Sprintf("[%s] %s", finding.Rule, finding.Message),
     ))
   }
-  return astDiags, lintDiags
+  return astDiags, lintDiags, false, nil
 }
 
 // RuleCode hashes a rule name into a stable, positive int32 so the