@eslinted/core 13.0.0 → 13.1.0-rc.1

package/src/factory/ruleset.ts

@@ -1,27 +1,23 @@
-import type {
-  Scopes,
-  RuleEntry,
-  RuleRecord,
-} from "..";
+import type { Scopes, Rule } from "..";
 
 export class Ruleset {
-  public readonly ruleset: { id: `${Scopes}:${string}`; rules: RuleRecord }[];
+  public readonly ruleset: { id: `${Scopes}:${string}`; rules: Rule.Config }[];
 
   constructor(
     public readonly scope: Scopes,
-    defaults: RuleEntry[],
-    extension?: RuleRecord,
+    defaults: readonly Rule.Entry[],
+    override?: Rule.Config,
   ) {
-    const map = ([id, rules]: RuleEntry) => ({
+    const map = ([id, rules]: Rule.Entry) => ({
       id: `${scope}:${id}`,
       rules,
     } as const);
 
     this.ruleset = [
       ...defaults.map(rule => map(rule)),
-      ...typeof extension === "undefined"
-        ? []
-        : [map([`${scope}:override`, extension])],
-    ];
+      ...typeof override === "undefined"
+        ? [] as const
+        : [map([`${scope}:override`, override])] as const,
+    ] as const;
   }
 }

package/src/factory/{options → settings}/index.ts

@@ -7,8 +7,7 @@ import json from "./scopes/json";
 import jsonc from "./scopes/jsonc";
 import yml from "./scopes/yml";
 
-export type * from "./option";
-export type * from "./proto";
+export type * from "./setting";
 export default {
   js,
   ts,

package/src/factory/settings/scopes/html.ts

@@ -0,0 +1,16 @@
+import { ScopeSetting } from "../setting";
+
+export default class HtmlSetting extends ScopeSetting<
+  "html",
+  true
+> {
+  public readonly scope = "html";
+  public readonly processor = {} as const;
+  public readonly language = {} as const;
+
+  public get languageOptions() {
+    const [parser] = this.parser;
+
+    return { parser } as const;
+  }
+}

package/src/factory/settings/scopes/js.ts

@@ -0,0 +1,11 @@
+import { ScopeSetting } from "../setting";
+
+export default class JsSetting extends ScopeSetting<"js"> {
+  public readonly scope = "js";
+  public readonly processor = {} as const;
+  public readonly language = {} as const;
+
+  public get languageOptions() {
+    return {} as const;
+  }
+}

package/src/factory/settings/scopes/json.ts

@@ -0,0 +1,16 @@
+import { ScopeSetting } from "../setting";
+
+export default class JsonSetting extends ScopeSetting<
+  "json",
+  true
+> {
+  public readonly scope = "json";
+  public readonly processor = {} as const;
+  public readonly language = {} as const;
+
+  public get languageOptions() {
+    const [parser] = this.parser;
+
+    return { parser } as const;
+  }
+}

package/src/factory/settings/scopes/jsonc.ts

@@ -0,0 +1,16 @@
+import { ScopeSetting } from "../setting";
+
+export default class JsoncSetting extends ScopeSetting<
+  "jsonc",
+  true
+> {
+  public readonly scope = "jsonc";
+  public readonly processor = {} as const;
+  public readonly language = {} as const;
+
+  public get languageOptions() {
+    const [parser] = this.parser;
+
+    return { parser } as const;
+  }
+}

package/src/factory/settings/scopes/mocha.ts

@@ -0,0 +1,29 @@
+import { mocha } from "globals";
+import { ScopeSetting } from "../setting";
+import type TsSetting from "./ts";
+
+export default class MochaSetting extends ScopeSetting<
+  "mocha",
+  TsSetting["option"]["languageOptions"]["parserOptions"],
+  1,
+  "mocha"
+> {
+  public readonly scope = "mocha";
+  public readonly processor = {} as const;
+  public readonly language = {} as const;
+  public readonly types = ["mocha"] as const;
+
+  public get languageOptions() {
+    const [parser] = this.parser;
+
+    return {
+      parser,
+      parserOptions: {
+        project: "tsconfig.json",
+        sourceType: "module",
+        ecmaVersion: 2023,
+      } as const,
+      globals: mocha,
+    } as const;
+  }
+}

package/src/factory/{options → settings}/scopes/svelte.ts

@@ -1,19 +1,19 @@
-import Option from "../option";
-import type Ts from "./ts";
+import { ScopeSetting } from "../setting";
+import type TsSetting from "./ts";
 
-export default class Svelte extends Option<
+export default class SvelteSetting extends ScopeSetting<
   "svelte",
   {
-    parser: unknown;
-    extraFileExtensions: readonly [".svelte"];
-  } & Ts["option"]["languageOptions"]["parserOptions"],
+    readonly parser: unknown;
+    readonly extraFileExtensions: readonly [".svelte"];
+  } & TsSetting["option"]["languageOptions"]["parserOptions"],
   2,
   false,
-  { processor: "svelte/svelte" }
+  { readonly processor: "svelte/svelte" }
 > {
   public readonly scope = "svelte";
   public readonly processor = { processor: "svelte/svelte" } as const;
-  public readonly language = {};
+  public readonly language = {} as const;
 
   public get languageOptions() {
     const [parser, tsParser] = this.parser;
@@ -26,7 +26,7 @@ export default class Svelte extends Option<
         project: "tsconfig.json",
         sourceType: "module",
         ecmaVersion: 2023,
-      },
+      } as const,
     } as const;
   }
 }

package/src/factory/settings/scopes/ts.ts

@@ -0,0 +1,28 @@
+import { ScopeSetting } from "../setting";
+
+export default class TsSetting extends ScopeSetting<
+  "ts",
+  {
+    readonly project: "tsconfig.json";
+    readonly sourceType: "module";
+    readonly ecmaVersion: 2023;
+  },
+  1
+> {
+  public readonly scope = "ts";
+  public readonly processor = {} as const;
+  public readonly language = {} as const;
+
+  public get languageOptions() {
+    const [parser] = this.parser;
+
+    return {
+      parser,
+      parserOptions: {
+        project: "tsconfig.json",
+        sourceType: "module",
+        ecmaVersion: 2023,
+      } as const,
+    } as const;
+  }
+}

package/src/factory/settings/scopes/yml.ts

@@ -0,0 +1,17 @@
+import { ScopeSetting } from "../setting";
+
+export default class YmlSetting extends ScopeSetting<
+  "yml",
+  true,
+  1
+> {
+  public readonly scope = "yml";
+  public readonly processor = {} as const;
+  public readonly language = {} as const;
+
+  public get languageOptions() {
+    const [parser] = this.parser;
+
+    return { parser } as const;
+  }
+}

package/src/factory/settings/setting.ts

@@ -0,0 +1,63 @@
+import type globals from "globals";
+import type { Scopes } from "../..";
+
+export abstract class ScopeSetting<
+  S extends Scopes,
+  ParserOptions extends
+  | object
+  | boolean = false,
+  ParserCount extends 0 | 1 | 2 = ParserOptions extends false ? 0 : 1,
+  G extends keyof typeof globals & (
+    | "mocha"
+  ) | false = false,
+  Processor extends object = object,
+  Language extends object = object,
+> {
+  public abstract readonly scope: S;
+  public abstract readonly processor: (Processor extends never
+    ? object
+    : Processor extends { readonly processor: infer P }
+      ? string extends P
+        ? object
+        : { readonly processor: P }
+      : object);
+  public abstract readonly language: (Language extends never
+    ? object
+    : Language extends { readonly language: infer L }
+      ? string extends L
+        ? object
+        : { readonly language: L }
+      : object);
+  constructor(public readonly parser: readonly unknown[] & { length: ParserCount }) {}
+
+  public get option() {
+    try {
+      const { languageOptions, processor, language } = this;
+
+      return {
+        languageOptions,
+        ...processor,
+        ...language,
+      } as const;
+    }
+    catch (e) { throw new Error(`linted.factory.Option/scope:${this.scope}: option`, { cause: e }); }
+  }
+
+  protected abstract get languageOptions():
+    (G extends never
+      ? object
+      : G extends boolean
+        ? object
+        : G extends string
+          ? string extends G
+            ? object
+            : { readonly globals: Readonly<Record<string, unknown>> }
+          : object
+    ) & ParserOptions extends never
+      ? object
+      : ParserOptions extends boolean
+        ? ParserOptions extends true
+          ? { readonly parser: unknown }
+          : object
+        : { readonly parser: unknown; readonly parserOptions: ParserOptions };
+}

package/src/index.ts

@@ -1,84 +1,35 @@
+import { scopes } from "./scopes";
+import { Factory, Options } from "./factory";
 import type { Input, Output } from "./interface";
 
 export type { Scopes } from "./scopes";
-
-import { scopes } from "./scopes";
-import {
-  GlobalFactory,
-  ScopeFactory,
-  Options,
-} from "./factory";
-
 export type * from "./interface";
-export type * from "./config";
-export default function (
-  {
-    imports: {
-      plugins,
-      parsers,
-    },
-    defaults,
-    extensions,
-  }: Input,
-): Output {
+export default function ({
+  imports: { plugins, parsers },
+  defaults,
+  extensions,
+}: Input): Output {
   try {
-    const global = new GlobalFactory(
-      plugins,
-      defaults.settings,
-      defaults.ignores["*"],
-      extensions["*"],
-    ),
-    factory = new ScopeFactory(
-      defaults,
-      extensions,
-    ),
-    options: { [S in typeof scopes[number]]: InstanceType<typeof Options[S]>["configs"] } = {
-      js: new Options
-        .js(
-          [],
-          ...factory.produce("js"),
-        ).configs,
-      ts: new Options
-        .ts(
-          [parsers.ts],
-          ...factory.produce("ts"),
-        ).configs,
-      svelte: new Options
-        .svelte(
-          [parsers.svelte, parsers.ts],
-          ...factory.produce("svelte"),
-        ).configs,
-      mocha: new Options
-        .mocha(
-          [parsers.ts],
-          ...factory.produce("mocha"),
-        ).configs,
-      html: new Options
-        .html(
-          [parsers.html],
-          ...factory.produce("html"),
-        ).configs,
-      json: new Options
-        .json(
-          [parsers.jsonc],
-          ...factory.produce("json"),
-        ).configs,
-      jsonc: new Options
-        .jsonc(
-          [parsers.jsonc],
-          ...factory.produce("jsonc"),
-        ).configs,
-      yml: new Options
-        .yml(
-          [parsers.yml],
-          ...factory.produce("yml"),
-        ).configs,
-    };
+    const factory = new Factory(defaults, extensions),
+    options: { readonly [S in typeof scopes[number]]: InstanceType<typeof Options[S]> } = {
+      js: new Options.js([] as const),
+      ts: new Options.ts([parsers.ts] as const),
+      svelte: new Options.svelte([parsers.svelte, parsers.ts] as const),
+      mocha: new Options.mocha([parsers.ts] as const),
+      html: new Options.html([parsers.html] as const),
+      json: new Options.json([parsers.jsonc] as const),
+      jsonc: new Options.jsonc([parsers.jsonc] as const),
+      yml: new Options.yml([parsers.yml] as const),
+    } as const;
 
     return [
-      ...global.configs,
-      ...scopes.flatMap(scope => options[scope]),
-    ];
+      { name: `linted/*/plugins`, plugins } as const,
+      factory.settings,
+      factory.ignores,
+      ...scopes.flatMap(scope => factory.scope(scope, options[scope])),
+    ] as const;
+  }
+  catch (e) {
+    throw new Error(`Linted Core`, { cause: e });
   }
-  catch (e) { throw new Error(`Linted Core`, { cause: e }); }
 }

package/src/interface/config/index.ts

@@ -0,0 +1,42 @@
+import type * as Rule from "./rule";
+
+export type { Rule };
+export interface Config<Plugins extends string = string> {
+  readonly name: `linted/${string}`;
+  readonly plugins: Readonly<Record<Plugins, { readonly configs: unknown }>>;
+  readonly files: readonly string[];
+  readonly ignores: readonly string[];
+  readonly rules: Rule.Config;
+  readonly linterOptions: {
+    readonly noInlineConfig: boolean;
+    readonly reportUnusedDisableDirectives:
+      | "error"
+      | "warn"
+      | "off"
+    ;
+  };
+  readonly languageOptions: {
+    readonly sourceType:
+      | "module"
+      | "script"
+    ;
+    readonly ecmaVersion:
+      | "latest"
+      | 3
+      | 5
+      | 2015
+      | 2016
+      | 2017
+      | 2018
+      | 2019
+      | 2020
+      | 2021
+      | 2022
+      | 2023
+      | 2024
+    ;
+  };
+  readonly processor?: string;
+  readonly language?: string;
+  readonly settings?: Readonly<Record<string, unknown>>;
+}

package/src/interface/config/rule.ts

@@ -0,0 +1,14 @@
+export type Entry = readonly [
+  string,
+  Config,
+];
+export type Config = Readonly<Record<
+  string,
+  | State
+  | readonly [State, ...readonly unknown[]]
+>>;
+export type State = (
+  | "error"
+  | "warn"
+  | "off"
+);

package/src/interface/configs/globals/ignores.ts

@@ -0,0 +1,10 @@
+import type { Config } from "../..";
+import type { Only } from "./only";
+
+export type Ignores = Only<
+  Config,
+  (
+    & { readonly name: `linted/*/ignores` }
+    & Pick<Config, "ignores">
+  )
+>;

package/src/interface/configs/globals/index.ts

@@ -0,0 +1,4 @@
+export type * from "./plugins";
+export type * from "./settings";
+export type * from "./ignores";
+export type * from "./only";

package/src/interface/configs/globals/only/index.ts

@@ -0,0 +1,4 @@
+export type Only<
+  Base extends object,
+  This extends object,
+> = This & Readonly<Partial<Record<Exclude<keyof Base, keyof This>, never>>>;

package/src/interface/configs/globals/plugins.ts

@@ -0,0 +1,10 @@
+import type { Config, Imports } from "../..";
+import type { Only } from "./only";
+
+export type Plugins = Only<
+  Config,
+  (
+    & { readonly name: `linted/*/plugins` }
+    & Pick<Config<Imports.Plugins>, "plugins">
+  )
+>;

package/src/interface/configs/globals/settings.ts

@@ -0,0 +1,13 @@
+import type { Config } from "../..";
+import type { Only } from "./only";
+
+export type Settings = Only<
+  Config,
+  (
+    & {
+      readonly name: `linted/*/settings`;
+      readonly languageOptions: Pick<Config["languageOptions"], "ecmaVersion" | "sourceType">;
+    }
+    & Pick<Config, "linterOptions">
+  )
+>;

package/src/interface/configs/index.ts

@@ -0,0 +1,2 @@
+export type * as Globals from "./globals";
+export type * from "./scoped";

package/src/interface/configs/scoped.ts

@@ -0,0 +1,7 @@
+import type { Config } from "..";
+import type { Scopes } from "../..";
+
+export type Scoped = {
+  readonly name: `linted/${Scopes}:${string}`;
+  readonly languageOptions: Omit<Config["languageOptions"], "sourceType" | "ecmaVersion">;
+} & Pick<Config, "files" | "ignores" | "rules" | "processor" | "language" | "settings">;

package/src/interface/imports/index.ts

@@ -1,16 +1,2 @@
-export type ImportPlugins = (
-  | "@stylistic"
-  | "@typescript-eslint"
-  | "svelte"
-  | "mocha"
-  | "@html-eslint"
-  | "jsonc"
-  | "yml"
-);
-export type ImportParsers = (
-  | "ts"
-  | "svelte"
-  | "html"
-  | "jsonc"
-  | "yml"
-);
+export type * from "./plugins";
+export type * from "./parsers";

package/src/interface/imports/parsers.ts

@@ -0,0 +1,7 @@
+export type Parsers = (
+  | "ts"
+  | "svelte"
+  | "html"
+  | "jsonc"
+  | "yml"
+);

package/src/interface/imports/plugins.ts

@@ -0,0 +1,9 @@
+export type Plugins = (
+  | "@stylistic"
+  | "@typescript-eslint"
+  | "svelte"
+  | "mocha"
+  | "@html-eslint"
+  | "jsonc"
+  | "yml"
+);

package/src/interface/index.ts

@@ -1,3 +1,4 @@
+export type * as Imports from "./imports";
+export type * from "./config";
 export type * from "./input";
 export type * from "./output";
-export type * from "./imports";

package/src/interface/input.ts

@@ -1,26 +1,22 @@
-import type {
-  Scopes,
-  Config,
-  RuleEntry,
-} from "..";
-import type { ImportPlugins, ImportParsers } from "./imports";
+import type { Config, Rule, Imports } from ".";
+import type { Scopes } from "..";
 
 export interface Input {
-  imports: {
-    plugins: Config<ImportPlugins>["plugins"];
-    parsers: Record<
-      ImportParsers & Scopes,
+  readonly imports: {
+    readonly plugins: Config<Imports.Plugins>["plugins"];
+    readonly parsers: Readonly<Record<
+      Imports.Parsers,
       unknown
-    >;
+    >>;
   };
-  defaults: {
-    settings: Config["linterOptions"] & Pick<Config["languageOptions"], "ecmaVersion" | "sourceType">;
-    files: Record<"*" | Scopes, string[]>;
-    ignores: Input["defaults"]["files"];
-    rules: Record<Scopes, RuleEntry[]>;
+  readonly defaults: {
+    readonly settings: Config["linterOptions"] & Pick<Config["languageOptions"], "ecmaVersion" | "sourceType">;
+    readonly files: Readonly<Record<"*" | Scopes, readonly string[]>>;
+    readonly ignores: Input["defaults"]["files"];
+    readonly rules: Readonly<Record<Scopes, readonly Rule.Entry[]>>;
   };
-  extensions: Partial<
-    & Record<"*", Partial<Input["defaults"]["settings"] & Pick<Config, "ignores"> & { override?: boolean }>>
+  readonly extensions: Readonly<Partial<
+    & Record<"*", Partial<Input["defaults"]["settings"] & Pick<Config, "ignores"> & { readonly override?: boolean }>>
     & Record<Scopes, Partial<Pick<Config, "files" | "ignores" | "rules">>>
-  >;
+  >>;
 }

package/src/interface/output.ts

@@ -1,24 +1,9 @@
-import type {
-  Scopes,
-  Config,
-} from "..";
-import type { ImportPlugins } from "./imports";
+import type * as Configs from "./configs";
 
-export type Exclusive<Base extends object, Cool extends object> = Cool & Partial<Record<Exclude<keyof Base, keyof Cool>, never>>;
-export type Output = [
-  Exclusive<
-    Config,
-    {
-      name: `linted/*/settings`;
-      languageOptions: Pick<Config["languageOptions"], "ecmaVersion" | "sourceType">;
-    } & Pick<Config<ImportPlugins>, "plugins" | "linterOptions">
-  >,
-  Exclusive<
-    Config,
-    { name: `linted/*/ignores` } & Pick<Config, "ignores">
-  >,
-  ...({
-    name: `linted/${Scopes}:${string}`;
-    languageOptions: Omit<Config["languageOptions"], "sourceType" | "ecmaVersion">;
-  } & Pick<Config, "files" | "ignores" | "rules" | "processor" | "language" | "settings">)[],
+export type { Configs };
+export type Output = readonly [
+  Configs.Globals.Plugins,
+  Configs.Globals.Settings,
+  Configs.Globals.Ignores,
+  ...readonly Configs.Scoped[],
 ];

package/dist/config/index.d.ts

@@ -1,23 +0,0 @@
-import type { RuleRecord } from "./rule.js";
-export type * from "./rule.js";
-export interface Config<Plugins extends string = string> {
-    name: `linted/${string}`;
-    plugins: Record<Plugins, {
-        configs: unknown;
-    }>;
-    files: string[];
-    ignores: string[];
-    rules: RuleRecord;
-    linterOptions: {
-        noInlineConfig: boolean;
-        reportUnusedDisableDirectives: "error" | "warn" | "off";
-    };
-    languageOptions: {
-        sourceType: "module" | "script";
-        ecmaVersion: "latest" | 3 | 5 | 2015 | 2016 | 2017 | 2018 | 2019 | 2020 | 2021 | 2022 | 2023 | 2024;
-    };
-    processor?: string;
-    language?: string;
-    settings?: Record<string, unknown>;
-}
-//# sourceMappingURL=index.d.ts.map