@ttsc/lint 0.11.0 → 0.12.0

package/src/structures/{TtscLintFormatConfig.ts → ITtscLintFormatConfig.ts}

@@ -9,21 +9,24 @@ import type { TtscLintSeverity } from "./TtscLintSeverity";
  * verbatim. The block is opt-in by presence: a `lint.config.ts` with no
  * `format` field keeps every format rule off, exactly as before.
  *
- * Once present, the block enables a curated set of format rules at
- * Prettier-aligned defaults. Individual rules can be overridden or
- * disabled through the `rules` map (the `rules` entry wins on conflict).
+ * Once present, the block configures a curated set of format rules at
+ * Prettier-aligned defaults. `ttsc format` uses these rules to rewrite source.
+ * `ttsc check` does not report format findings unless `severity` is set to a
+ * non-off value. Individual rules can be overridden or disabled through the
+ * `rules` map (the `rules` entry wins on conflict).
  *
  * @example
- *   import type { TtscLintConfig } from "@ttsc/lint";
+ *   import type { ITtscLintConfig } from "@ttsc/lint";
  *
  *   export default {
  *     rules: { "no-var": "error" },
  *     format: {
+ *       severity: "warning",
  *       printWidth: 100,
  *       singleQuote: true,
  *       importOrder: ["<THIRD_PARTY_MODULES>", "^[./]"],
  *     },
- *   } satisfies TtscLintConfig;
+ *   } satisfies ITtscLintConfig;
  *
  * Deviations from Prettier:
  *  - `endOfLine` is restricted to `"lf"` and `"crlf"`. Prettier's
@@ -31,7 +34,6 @@ import type { TtscLintSeverity } from "./TtscLintSeverity";
  *    printer does not auto-detect terminators.
  *  - Many Prettier knobs (`bracketSpacing`, `arrowParens`,
  *    `quoteProps`, JSX-specific switches) are not yet implemented.
- *    See `docs/14-prettier-migration.md` for the full gap list.
  *
  * Rule enablement matrix (when the `format` block is present):
  *
@@ -46,19 +48,18 @@ import type { TtscLintSeverity } from "./TtscLintSeverity";
  *  - `format/sort-imports` — opt-in. Setting `importOrder` enables it.
  *  - `format/jsdoc` — opt-in. Setting `jsdoc` enables it.
  *
- * For per-rule severity overrides, drop a `rules` entry alongside:
- *
- *   format: { semi: true, severity: "warning" },
- *   rules: { "format/semi": "error" },
+ * Format findings produced from this block are off by default. Set `severity`
+ * only when a project intentionally wants check-time format diagnostics.
  */
-export interface TtscLintFormatConfig {
+export interface ITtscLintFormatConfig {
   /**
-   * Severity for every format diagnostic emitted by `ttsc check`. The
-   * same vocabulary as the `rules` map (`"off" | "warn" | "warning" |
-   * "error"` plus numeric 0/1/2). `"off"` disables both the diagnostic
-   * and the `ttsc format` / `ttsc fix` rewrite for every format rule.
+   * Check-time severity for format findings generated from this block.
+   *
+   * The default is `"off"` so formatting policy does not affect compilation
+   * unless the project opts into that behavior. `ttsc format` can still use the
+   * rest of this block to rewrite files.
    *
-   * @default "warning"
+   * @default "off"
    */
   severity?: TtscLintSeverity;
 

package/src/structures/ITtscLintPluginConfig.ts

@@ -1,4 +1,4 @@
-import type { TtscLintFormatConfig } from "./TtscLintFormatConfig";
+import type { ITtscLintFormatConfig } from "./ITtscLintFormatConfig";
 import type { TtscLintRuleMap } from "./TtscLintRuleMap";
 
 /** `compilerOptions.plugins[]` entry shape consumed by `@ttsc/lint`. */
@@ -67,7 +67,7 @@ export interface ITtscLintPluginConfig {
 
   /**
    * Prettier-style flat configuration for the `format/*` rules. Sibling of
-   * `rules`. See {@link TtscLintFormatConfig} for the full surface.
+   * `rules`. See {@link ITtscLintFormatConfig} for the full surface.
    *
    * ```jsonc
    * {
@@ -80,7 +80,7 @@ export interface ITtscLintPluginConfig {
    * combined with `extends` on the same plugin entry — put format options
    * inside the extends-target lint.config.ts instead.
    */
-  format?: TtscLintFormatConfig;
+  format?: ITtscLintFormatConfig;
 
   /**
    * Inline rule map or path to a standalone lint config file.
@@ -92,9 +92,9 @@ export interface ITtscLintPluginConfig {
    *
    *   The legacy shape is intentionally narrower than `rules`/`extends`: a string
    *   (file path) or a flat rule-name → severity map. The Go-side parser only
-   *   accepts those two shapes; widening the TS type to the new
-   *   `TtscLintConfig` union would silently let `config: [{ rules: {...} }]`
-   *   pass type-checking and fail at runtime.
+   *   accepts those two shapes; widening the TS type to the full config object
+   *   would silently let unsupported nested shapes pass type-checking and fail
+   *   at runtime.
    */
   config?: string | TtscLintRuleMap;
 

package/src/structures/TtscLintRuleMap.ts

@@ -1,7 +1,5 @@
-import type { PluginRuleNames } from "./PluginRuleNames";
-import type { TtscLintPlugins } from "./TtscLintPlugins";
 import type { TtscLintRule } from "./TtscLintRule";
-import type { TtscLintRuleOptionsMap } from "./TtscLintRuleOptions";
+import type { ITtscLintRuleOptionsMap } from "./TtscLintRuleOptions";
 import type { TtscLintSeverity } from "./TtscLintSeverity";
 
 /**
@@ -9,10 +7,12 @@ import type { TtscLintSeverity } from "./TtscLintSeverity";
  *
  * Built from two independent mapped types intersected together:
  *
- * - Rules listed in `TtscLintRuleOptionsMap` accept `severity`, `[severity]`, or
+ * - Rules listed in `ITtscLintRuleOptionsMap` accept `severity`, `[severity]`, or
  *   `[severity, options]`, with the options type picked per rule key.
- * - Every other built-in rule plus any contributor plugin rule accepts `severity`
- *   or `[severity]`.
+ * - Every other built-in rule accepts `severity` or `[severity]`.
+ * - Namespaced contributor plugin rules accept `severity`, `[severity]`, or
+ *   `[severity, unknownOptions]` because the host type surface no longer
+ *   knows contributor rule schemas.
  *
  * Splitting the two halves (instead of folding them into one mapped type with a
  * conditional value) keeps TypeScript's contextual typing intact inside the
@@ -38,15 +38,19 @@ import type { TtscLintSeverity } from "./TtscLintSeverity";
  * splits each negative case into its own const to keep every branch
  * load-bearing.
  */
-export type TtscLintRuleMap<P extends TtscLintPlugins = Record<string, never>> =
+export type TtscLintRuleMap =
   {
-    [K in keyof TtscLintRuleOptionsMap]?:
+    [K in keyof ITtscLintRuleOptionsMap]?:
       | TtscLintSeverity
       | readonly [TtscLintSeverity]
-      | readonly [TtscLintSeverity, TtscLintRuleOptionsMap[K]];
+      | readonly [TtscLintSeverity, ITtscLintRuleOptionsMap[K]];
   } & {
-    [K in Exclude<
-      TtscLintRule | PluginRuleNames<P>,
-      keyof TtscLintRuleOptionsMap
-    >]?: TtscLintSeverity | readonly [TtscLintSeverity];
+    [K in Exclude<TtscLintRule, keyof ITtscLintRuleOptionsMap>]?:
+      | TtscLintSeverity
+      | readonly [TtscLintSeverity];
+  } & {
+    [K in `${string}/${string}`]?:
+      | TtscLintSeverity
+      | readonly [TtscLintSeverity]
+      | readonly [TtscLintSeverity, unknown];
   };

package/src/structures/TtscLintRuleOptions.ts

@@ -1,162 +1,136 @@
-/**
- * Per-rule option shapes used by `TtscLintRuleEntry` to type the second tuple
- * slot.
- *
- * Each entry here maps a rule name to its option struct. Rule names that do not
- * appear in this interface accept severity-only configuration (a `[severity]`
- * tuple is _also_ allowed for them, with an empty options blob).
- *
- * The shapes are designed to match the analogous prettier / ESLint options
- * where the rule absorbs an existing tool's behavior:
- *
- * - `format/semi` mirrors prettier `semi`.
- * - `format/quotes` mirrors prettier `singleQuote` (inverted).
- * - `format/trailing-comma` mirrors prettier `trailingComma`.
- * - `format/sort-imports` mirrors `@trivago/prettier-plugin-sort-imports`
- *   (`importOrder`, `importOrderSeparation`, `importOrderSortSpecifiers`,
- *   `importOrderCaseInsensitive`).
- * - `format/jsdoc` mirrors `prettier-plugin-jsdoc` (`tagSynonyms` layered onto
- *   the built-in synonym table, `sortTags` reserved for a future pass).
- *
- * Future option additions go here so the TypeScript autocomplete updates in one
- * place. The Go side reads these as `json.RawMessage` and each rule decodes
- * into its own struct.
- */
-export namespace TtscLintRuleOptions {
-  /** `format/semi` options. */
-  export interface Semi {
-    /**
-     * Whether trailing semicolons must be present on ASI statements.
-     *
-     * @default "always"
-     */
-    prefer?: "always" | "never";
-  }
+/** `format/semi` rule options. */
+export interface ITtscLintSemiRuleOptions {
+  /**
+   * Whether trailing semicolons must be present on ASI statements.
+   *
+   * @default "always"
+   */
+  prefer?: "always" | "never";
+}
 
-  /** `format/quotes` options. */
-  export interface Quotes {
-    /**
-     * Quote style for string literals. Template literals are always preserved
-     * regardless of this setting.
-     *
-     * @default "double"
-     */
-    prefer?: "double" | "single";
-  }
+/** `format/quotes` rule options. */
+export interface ITtscLintQuotesRuleOptions {
+  /**
+   * Quote style for string literals. Template literals are always preserved
+   * regardless of this setting.
+   *
+   * @default "double"
+   */
+  prefer?: "double" | "single";
+}
 
-  /** `format/trailing-comma` options. */
-  export interface TrailingComma {
-    /**
-     * Which multi-line lists receive a trailing comma. `"all"` matches
-     * prettier's modern default; `"es5"` skips function calls and type
-     * parameter lists; `"none"` disables the rule entirely.
-     *
-     * @default "all"
-     */
-    mode?: "all" | "es5" | "none";
-  }
+/** `format/trailing-comma` rule options. */
+export interface ITtscLintTrailingCommaRuleOptions {
+  /**
+   * Which multi-line lists receive a trailing comma. `"all"` matches prettier's
+   * modern default; `"es5"` skips function calls and type parameter lists;
+   * `"none"` disables the rule entirely.
+   *
+   * @default "all"
+   */
+  mode?: "all" | "es5" | "none";
+}
 
-  /** `format/sort-imports` options. */
-  export interface SortImports {
-    /**
-     * Ordered list of regex strings (or the `<THIRD_PARTY_MODULES>`
-     * placeholder) defining the group order. Imports matching the first pattern
-     * land in group 0, the second in group 1, and so on. The placeholder
-     * absorbs any specifier that does not match another pattern. Mirrors
-     * trivago's `importOrder` semantics.
-     */
-    importOrder?: readonly string[];
+/** `format/sort-imports` rule options. */
+export interface ITtscLintSortImportsRuleOptions {
+  /**
+   * Ordered list of regex strings (or the `<THIRD_PARTY_MODULES>` placeholder)
+   * defining the group order. Imports matching the first pattern land in group
+   * 0, the second in group 1, and so on. The placeholder absorbs any specifier
+   * that does not match another pattern. Mirrors trivago's `importOrder`
+   * semantics.
+   */
+  importOrder?: readonly string[];
 
-    /**
-     * Insert a blank line between groups.
-     *
-     * @default true
-     */
-    importOrderSeparation?: boolean;
+  /**
+   * Insert a blank line between groups.
+   *
+   * @default true
+   */
+  importOrderSeparation?: boolean;
 
-    /**
-     * Sort named import specifiers alphabetically within each declaration.
-     *
-     * @default true
-     */
-    importOrderSortSpecifiers?: boolean;
+  /**
+   * Sort named import specifiers alphabetically within each declaration.
+   *
+   * @default true
+   */
+  importOrderSortSpecifiers?: boolean;
 
-    /**
-     * Treat `A` and `a` as equivalent when comparing module specifiers and
-     * specifier names. Mirrors trivago's `importOrderCaseInsensitive`.
-     *
-     * @default false
-     */
-    importOrderCaseInsensitive?: boolean;
-  }
+  /**
+   * Treat `A` and `a` as equivalent when comparing module specifiers and
+   * specifier names. Mirrors trivago's `importOrderCaseInsensitive`.
+   *
+   * @default false
+   */
+  importOrderCaseInsensitive?: boolean;
+}
 
-  /** `format/print-width` options. */
-  export interface PrintWidth {
-    /**
-     * Maximum column width before broken-form layout is chosen. Mirrors
-     * prettier's `printWidth`.
-     *
-     * @default 80
-     */
-    printWidth?: number;
+/** `format/print-width` rule options. */
+export interface ITtscLintPrintWidthRuleOptions {
+  /**
+   * Maximum column width before broken-form layout is chosen. Mirrors
+   * prettier's `printWidth`.
+   *
+   * @default 80
+   */
+  printWidth?: number;
 
-    /**
-     * Indentation increment in columns. Mirrors prettier's `tabWidth`.
-     *
-     * @default 2
-     */
-    tabWidth?: number;
+  /**
+   * Indentation increment in columns. Mirrors prettier's `tabWidth`.
+   *
+   * @default 2
+   */
+  tabWidth?: number;
 
-    /**
-     * Emit indentation as tab characters rather than spaces. Mirrors
-     * prettier's `useTabs`. Continuation alignment beyond the tab
-     * boundary still falls back to spaces, matching dprint's
-     * "indent with tabs, align with spaces" convention.
-     *
-     * @default false
-     */
-    useTabs?: boolean;
+  /**
+   * Emit indentation as tab characters rather than spaces. Mirrors prettier's
+   * `useTabs`. Continuation alignment beyond the tab boundary still falls back
+   * to spaces, matching dprint's "indent with tabs, align with spaces"
+   * convention.
+   *
+   * @default false
+   */
+  useTabs?: boolean;
 
-    /**
-     * Line-terminator emitted on every newline the printer inserts.
-     * Mirrors prettier's `endOfLine` `"lf"` and `"crlf"` modes.
-     *
-     * @default "lf"
-     */
-    endOfLine?: "lf" | "crlf";
-  }
+  /**
+   * Line-terminator emitted on every newline the printer inserts. Mirrors
+   * prettier's `endOfLine` `"lf"` and `"crlf"` modes.
+   *
+   * @default "lf"
+   */
+  endOfLine?: "lf" | "crlf";
+}
 
-  /** `format/jsdoc` options. */
-  export interface JSDoc {
-    /**
-     * Extra `from → to` tag rewrites layered on top of the built-in synonym
-     * table (`@return → @returns`, `@arg → @param`, etc.). User-supplied
-     * entries win on key collision, so a `{"return": "RETURN"}` entry overrides
-     * the built-in default for `@return`.
-     *
-     * @default {} (use built-in table unchanged)
-     */
-    tagSynonyms?: Record<string, string>;
+/** `format/jsdoc` rule options. */
+export interface ITtscLintJsdocRuleOptions {
+  /**
+   * Extra `from -> to` tag rewrites layered on top of the built-in synonym
+   * table (`@return -> @returns`, `@arg -> @param`, etc.). User-supplied
+   * entries win on key collision, so a `{"return": "RETURN"}` entry overrides
+   * the built-in default for `@return`.
+   *
+   * @default {} (use built-in table unchanged)
+   */
+  tagSynonyms?: Record<string, string>;
 
-    /**
-     * Sort JSDoc tag blocks into the canonical order (`@description`, `@param`,
-     * `@returns`, …).
-     *
-     * @default false (deferred; MVP only normalizes tag names)
-     */
-    sortTags?: boolean;
-  }
+  /**
+   * Sort JSDoc tag blocks into the canonical order (`@description`, `@param`,
+   * `@returns`, ...).
+   *
+   * @default false (deferred; MVP only normalizes tag names)
+   */
+  sortTags?: boolean;
 }
 
 /**
- * Index from rule name to its option struct. Used by `TtscLintRuleEntry<R>` to
+ * Index from rule name to its option object. `TtscLintRuleMap` uses this to
  * produce precise tuple types per rule.
  */
-export interface TtscLintRuleOptionsMap {
-  "format/semi": TtscLintRuleOptions.Semi;
-  "format/quotes": TtscLintRuleOptions.Quotes;
-  "format/trailing-comma": TtscLintRuleOptions.TrailingComma;
-  "format/sort-imports": TtscLintRuleOptions.SortImports;
-  "format/jsdoc": TtscLintRuleOptions.JSDoc;
-  "format/print-width": TtscLintRuleOptions.PrintWidth;
+export interface ITtscLintRuleOptionsMap {
+  "format/semi": ITtscLintSemiRuleOptions;
+  "format/quotes": ITtscLintQuotesRuleOptions;
+  "format/trailing-comma": ITtscLintTrailingCommaRuleOptions;
+  "format/sort-imports": ITtscLintSortImportsRuleOptions;
+  "format/jsdoc": ITtscLintJsdocRuleOptions;
+  "format/print-width": ITtscLintPrintWidthRuleOptions;
 }

package/src/structures/index.ts

@@ -1,14 +1,9 @@
-export * from "./defaultFormat";
+export * from "./ITtscLintConfig";
+export * from "./ITtscLintFormatConfig";
 export * from "./ITtscLintPlugin";
 export * from "./ITtscLintPluginConfig";
 export * from "./ITtscLintPluginMeta";
-export * from "./PluginRuleNames";
-export * from "./TtscLintConfig";
-export * from "./TtscLintConfigEntry";
-export * from "./TtscLintFormatConfig";
-export * from "./TtscLintPlugins";
 export * from "./TtscLintRule";
-export * from "./TtscLintRuleEntry";
 export * from "./TtscLintRuleMap";
 export * from "./TtscLintRuleOptions";
 export * from "./TtscLintSeverity";

package/lib/defineConfig.d.ts

@@ -1,55 +0,0 @@
-import type { TtscLintConfig } from "./structures/TtscLintConfig";
-import type { TtscLintPlugins } from "./structures/TtscLintPlugins";
-/**
- * Authoring helper that preserves the literal type of a lint config.
- *
- * ESLint's flat-config experience relies on `defineConfig` to capture the
- * const-narrowed type of the configuration array, which is what makes plugin
- * rule names autocomplete across entries. `@ttsc/lint` follows the same
- * pattern: pass your config through this helper and the contributor plugin
- * objects in `plugins` propagate their `rules` tuples into the rule-name
- * union.
- *
- * ```ts
- * import { defineConfig } from "@ttsc/lint";
- * import importPlugin from "@ttsc/lint-plugin-import";
- *
- * export default defineConfig([
- *   {
- *     plugins: { import: importPlugin },
- *     rules: {
- *       "no-var": "error",
- *       "import/no-cycle": ["error", { maxDepth: 1 }],
- *     },
- *   },
- * ]);
- * ```
- *
- * The function is a pure pass-through at runtime. The generic gymnastics below
- * gather every `plugins` map across the array of config entries into one
- * intersected `TtscLintPlugins` shape that gets threaded back into the
- * `TtscLintConfig<P>` constraint. Without this, `TtscLintConfig`'s default `P =
- * Record<string, never>` rules out every namespaced rule name and `{
- * "import/no-cycle": "error" }` would be flagged as a typo.
- */
-export declare function defineConfig<const T extends TtscLintConfig<GatherPlugins<T>>>(config: T): T;
-/**
- * Walks the input type to collect every plugin map declared across entries.
- * Single entries yield the entry's `plugins`; arrays intersect every entry's
- * `plugins` so each entry's rule-name union remains valid for the whole array.
- * The intersection (vs. union) is load-bearing — TypeScript's `keyof (A | B)`
- * collapses to `never`, which would reject every namespaced rule name.
- *
- * Plugins declared exclusively inside an `extends` chain are NOT collected:
- * recursing into `T extends { extends?: infer E } ? GatherPlugins<E> : {}`
- * blows TypeScript's instantiation budget (`extends` is itself a
- * `TtscLintConfigEntry` tree). Authors should declare each plugin's `plugins`
- * map on the outermost entry where its rules are configured. The runtime
- * resolver still picks up plugins from `extends` entries; only the autocomplete
- * domain is bounded.
- */
-type GatherPlugins<T> = T extends {
-    plugins?: infer P;
-} ? P extends TtscLintPlugins ? P : {} : T extends readonly (infer Item)[] ? UnionToIntersection<Item extends unknown ? GatherPlugins<Item> : never> : {};
-type UnionToIntersection<U> = (U extends unknown ? (x: U) => void : never) extends (x: infer I) => void ? I : never;
-export {};

package/lib/defineConfig.js

@@ -1,39 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.defineConfig = defineConfig;
-/**
- * Authoring helper that preserves the literal type of a lint config.
- *
- * ESLint's flat-config experience relies on `defineConfig` to capture the
- * const-narrowed type of the configuration array, which is what makes plugin
- * rule names autocomplete across entries. `@ttsc/lint` follows the same
- * pattern: pass your config through this helper and the contributor plugin
- * objects in `plugins` propagate their `rules` tuples into the rule-name
- * union.
- *
- * ```ts
- * import { defineConfig } from "@ttsc/lint";
- * import importPlugin from "@ttsc/lint-plugin-import";
- *
- * export default defineConfig([
- *   {
- *     plugins: { import: importPlugin },
- *     rules: {
- *       "no-var": "error",
- *       "import/no-cycle": ["error", { maxDepth: 1 }],
- *     },
- *   },
- * ]);
- * ```
- *
- * The function is a pure pass-through at runtime. The generic gymnastics below
- * gather every `plugins` map across the array of config entries into one
- * intersected `TtscLintPlugins` shape that gets threaded back into the
- * `TtscLintConfig<P>` constraint. Without this, `TtscLintConfig`'s default `P =
- * Record<string, never>` rules out every namespaced rule name and `{
- * "import/no-cycle": "error" }` would be flagged as a typo.
- */
-function defineConfig(config) {
-    return config;
-}
-//# sourceMappingURL=defineConfig.js.map

package/lib/defineConfig.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"defineConfig.js","sourceRoot":"","sources":["../src/defineConfig.ts"],"names":[],"mappings":";;;AAGA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,sBACE,MAAS;IAET,OAAO,MAAM,CAAC;AAChB,CAAC"}

package/lib/structures/PluginRuleNames.d.ts

@@ -1,14 +0,0 @@
-import type { TtscLintPlugins } from "./TtscLintPlugins";
-/**
- * Builds the union of `${namespace}/${rule}` strings from a plugins map.
- *
- * Each plugin's `rules` tuple is read literally: an `as const` tuple
- * (`["no-cycle", "order"] as const`) provides exact autocomplete, while a plain
- * `string[]` collapses to `${namespace}/${string}` and disables rule-level typo
- * detection for that namespace.
- */
-export type PluginRuleNames<P extends TtscLintPlugins> = {
-    [Ns in keyof P]: P[Ns] extends {
-        rules?: infer R;
-    } ? R extends readonly (infer N)[] ? N extends string ? `${Ns & string}/${N}` : never : never : never;
-}[keyof P];

package/lib/structures/PluginRuleNames.js.map

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

package/lib/structures/TtscLintConfig.d.ts

@@ -1,27 +0,0 @@
-import type { TtscLintConfigEntry } from "./TtscLintConfigEntry";
-import type { TtscLintPlugins } from "./TtscLintPlugins";
-import type { TtscLintRuleMap } from "./TtscLintRuleMap";
-/**
- * Top-level config accepted by `@ttsc/lint`.
- *
- * Three accepted forms, listed in expected order of preference:
- *
- * 1. **Flat-config array** — mirrors ESLint flat config exactly. Each entry can
- *    scope by `files` / `ignores`, declare a `plugins` map of contributors,
- *    configure `rules`, and configure formatting through the Prettier-style
- *    {@link TtscLintFormatConfig | `format`} block. Multiple entries layer in
- *    order.
- * 2. **Single config object** — same shape as one flat-config entry. Useful when
- *    the project has no per-file scoping. Pass `format: { … }` here for the
- *    smallest "describe my style" config.
- * 3. **Rules-only map** — historical shape kept for backward compat with
- *    single-file projects. `{"no-var":"error"}` is interpreted as `[{rules:
- *    {"no-var":"error"}}]`. The shorthand intentionally has no slot for the
- *    `format` block — use form (1) or (2) to enable formatting.
- *
- * The generic parameter `P` lets `defineConfig` capture the literal plugin
- * object types declared in `plugins`. When non-empty, rule-name keys
- * autocomplete as `BuiltInRule | "<ns>/<rule>"` where the namespace-rule
- * combinations come from each plugin's `rules` tuple.
- */
-export type TtscLintConfig<P extends TtscLintPlugins = Record<string, never>> = TtscLintRuleMap<P> | TtscLintConfigEntry<P> | readonly TtscLintConfigEntry<P>[];

package/lib/structures/TtscLintConfig.js.map

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

package/lib/structures/TtscLintConfigEntry.d.ts

@@ -1,39 +0,0 @@
-import type { TtscLintFormatConfig } from "./TtscLintFormatConfig";
-import type { TtscLintPlugins } from "./TtscLintPlugins";
-import type { TtscLintRuleMap } from "./TtscLintRuleMap";
-/**
- * One flat-config entry. ESLint-style `files` / `ignores` glob scoping, a
- * `plugins` namespace map of contributor plugin objects, an `extends` list of
- * child entries to fold in first, and a severity-keyed `rules` map applied
- * after the extends chain.
- *
- * Prettier-style formatting opts in through a sibling `format` block — see
- * `TtscLintFormatConfig`. The block can scope per-entry (e.g. wider
- * `printWidth` for `legacy/**`) just like `rules` does.
- */
-export interface TtscLintConfigEntry<P extends TtscLintPlugins = Record<string, never>> {
-    /** Globs that select the files this entry applies to. */
-    files?: string | readonly string[];
-    /** Globs that exclude files this entry would otherwise match. */
-    ignores?: string | readonly string[];
-    /**
-     * Nested entries (or arrays of entries) folded in before this entry's own
-     * rules apply. Mirrors ESLint flat config's `extends`: each child's rules
-     * layer first, with `this.rules` taking precedence on key collisions.
-     */
-    extends?: TtscLintConfigEntry<P> | readonly TtscLintConfigEntry<P>[] | readonly (TtscLintConfigEntry<P> | readonly TtscLintConfigEntry<P>[])[];
-    /**
-     * Contributor plugin objects keyed by namespace. Each value is the default
-     * export of a `@ttsc/lint` contributor package (an `ITtscLintPlugin`).
-     */
-    plugins?: P;
-    /** Rule-name → severity map. Supports severity tuples with options. */
-    rules?: TtscLintRuleMap<P>;
-    /**
-     * Prettier-style flat configuration for the `format/*` rules. Presence
-     * (even an empty `format: {}`) enables format-class rules at Prettier
-     * defaults; absence keeps them all off. Per-rule overrides go through
-     * the `rules` map — the `rules` entry wins on conflict.
-     */
-    format?: TtscLintFormatConfig;
-}

package/lib/structures/TtscLintConfigEntry.js

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