@eslinted/core 0.6.0 → 0.7.0-rc.4

package/src/factory/Factory.ts

@@ -0,0 +1,13 @@
+import Options from "./options/Options.js";
+import Files from "./files/Files.js";
+import Ruleset, { Rule } from "./ruleset/Ruleset.js";
+import type { Scope } from "../index.js";
+
+export type Blanka = ConstructorParameters<typeof Options["js"]>;
+export {
+  Options,
+  Files,
+  Ruleset,
+  Rule,
+  type Scope,
+};

package/src/factory/files/Files.ts

@@ -0,0 +1,15 @@
+import type { Scope } from "../Factory.js";
+
+export default class Files {
+  constructor(
+    private readonly base: Record<Scope, string[]>,
+    private readonly includes: Particord<Scope, string[]>,
+  ) {}
+
+  public files(scope: Scope): readonly string[] {
+    return [
+      ...this.base[scope],
+      ...this.includes[scope] ?? [],
+    ];
+  }
+}

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

@@ -1,4 +1,4 @@
-import type { Scope } from "../index.js";
+import type { Scope } from "../Factory.js";
 import JsOption from "./option/js/index.js";
 import TsOption from "./option/ts/index.js";
 import SvelteOption from "./option/svelte/index.js";
@@ -16,4 +16,4 @@ export default {
   json: JsonOption,
   jsonc: JsoncOption,
   yml: YmlOption,
-} satisfies Record<Scope, unknown>;
+} as const;

package/src/factory/options/option/Option.ts

@@ -0,0 +1,58 @@
+import type { Scope } from "../Options.js";
+
+export default abstract class Option<
+  S extends Scope,
+  PluginId extends string,
+  IsEcma extends boolean = true,
+  ParserOptions extends object | boolean = false,
+  ParserCount extends 0 | 1 | 2 = 0,
+  GlobalTypes extends string = never,
+  Processor extends object = never,
+> {
+  public readonly linterOptions = {
+    noInlineConfig: true,
+    reportUnusedDisableDirectives: "error",
+  } as const;
+
+  public abstract readonly name: literalful<`scope:${S}`>;
+  public abstract readonly processor: (Interface<Processor> extends never ? object : Interface<Processor> extends { "interface": string } ? Interface<Processor> : object);
+
+  constructor(
+    public readonly files: readonly string[],
+    public readonly plugins: IOPlugins<PluginId>,
+    public readonly parser: Tuple<unknown, ParserCount>,
+  ) {}
+
+  public get option() {
+    const {
+      name,
+      files,
+      plugins,
+      linterOptions,
+      languageOptions,
+      processor,
+    } = this;
+
+    return {
+      name,
+      files,
+      linterOptions,
+      languageOptions,
+      plugins,
+      ...processor,
+    } satisfies IOption<
+      `scope:${S}`,
+      PluginId,
+      IsEcma,
+      ParserOptions,
+      GlobalTypes,
+      Processor
+    >;
+  }
+
+  public abstract get languageOptions(): IOLanguage<
+    IsEcma,
+    ParserOptions,
+    GlobalTypes
+  >;
+}

package/src/factory/options/option/html/index.ts

@@ -1,31 +1,18 @@
-import Option from "../index.js";
+import Option from "../Option.js";
 
 export default class HtmlOption extends Option<
   "html",
   "@html-eslint",
+  false,
   true,
-  never,
-  never,
-  never,
-  never,
-  never
+  1
 > {
-  constructor(
-    plugins: HtmlOption["body"]["plugins"],
-    parser: HtmlOption["body"]["languageOptions"]["parser"],
-    files: readonly string[],
-  ) {
-    super(
-      {
-        name: "linted/scope:html",
-        files,
-        plugins,
-        linterOptions: {
-          noInlineConfig: true,
-          reportUnusedDisableDirectives: "error",
-        },
-        languageOptions: { parser },
-      },
-    );
+  public readonly name = "scope:html";
+  public readonly processor = {} as const;
+
+  public get languageOptions() {
+    const [parser] = this.parser;
+
+    return { parser } as const;
   }
 }

package/src/factory/options/option/js/index.ts

@@ -1,24 +1,13 @@
-import Option from "../index.js";
+import Option from "../Option.js";
 
 export default class JsOption extends Option<"js", "@stylistic"> {
-  constructor(
-    plugins: JsOption["body"]["plugins"],
-    files: readonly string[],
-  ) {
-    super(
-      {
-        name: "linted/scope:js",
-        files,
-        plugins,
-        linterOptions: {
-          noInlineConfig: true,
-          reportUnusedDisableDirectives: "error",
-        },
-        languageOptions: {
-          ecmaVersion: "latest",
-          sourceType: "module",
-        },
-      },
-    );
+  public readonly name = "scope:js";
+  public readonly processor = {};
+
+  public get languageOptions() {
+    return {
+      ecmaVersion: "latest",
+      sourceType: "module",
+    } as const;
   }
 }

package/src/factory/options/option/json/index.ts

@@ -1,31 +1,18 @@
-import Option from "../index.js";
+import Option from "../Option.js";
 
 export default class JsonOption extends Option<
   "json",
   "jsonc",
+  false,
   true,
-  never,
-  never,
-  never,
-  never,
-  never
+  1
 > {
-  constructor(
-    plugins: JsonOption["body"]["plugins"],
-    parser: JsonOption["body"]["languageOptions"]["parser"],
-    files: readonly string[],
-  ) {
-    super(
-      {
-        name: "linted/scope:json",
-        files,
-        plugins,
-        linterOptions: {
-          noInlineConfig: true,
-          reportUnusedDisableDirectives: "error",
-        },
-        languageOptions: { parser },
-      },
-    );
+  public readonly name = "scope:json";
+  public readonly processor = {} as const;
+
+  public get languageOptions() {
+    const [parser] = this.parser;
+
+    return { parser } as const;
   }
 }

package/src/factory/options/option/jsonc/index.ts

@@ -1,31 +1,18 @@
-import Option from "../index.js";
+import Option from "../Option.js";
 
 export default class JsoncOption extends Option<
   "jsonc",
   "jsonc",
+  false,
   true,
-  never,
-  never,
-  never,
-  never,
-  never
+  1
 > {
-  constructor(
-    plugins: JsoncOption["body"]["plugins"],
-    parser: JsoncOption["body"]["languageOptions"]["parser"],
-    files: readonly string[],
-  ) {
-    super(
-      {
-        name: "linted/scope:jsonc",
-        files,
-        plugins,
-        linterOptions: {
-          noInlineConfig: true,
-          reportUnusedDisableDirectives: "error",
-        },
-        languageOptions: { parser },
-      },
-    );
+  public readonly name = "scope:jsonc";
+  public readonly processor = {} as const;
+
+  public get languageOptions() {
+    const [parser] = this.parser;
+
+    return { parser } as const;
   }
 }

package/src/factory/options/option/svelte/index.ts

@@ -1,45 +1,34 @@
-import Option from "../index.js";
+import Option from "../Option.js";
 import type TsOption from "../ts/index.js";
 
 export default class SvelteOption extends Option<
   "svelte",
-  "svelte" | keyof TsOption["body"]["plugins"],
+  "svelte" | keyof TsOption["option"]["plugins"],
   true,
-  & TsOption["body"]["languageOptions"]["parserOptions"]
+  & TsOption["option"]["languageOptions"]["parserOptions"]
   & { parser: unknown }
-  & { extraFileExtensions: [".svelte"] },
+  & { extraFileExtensions: readonly [".svelte"] },
+  2,
   never,
-  "svelte/svelte"
+  { processor: "svelte/svelte" }
 > {
-  constructor(
-    plugins: SvelteOption["body"]["plugins"],
-    svelteParser: SvelteOption["body"]["languageOptions"]["parser"],
-    tsParser: SvelteOption["body"]["languageOptions"]["parserOptions"]["parser"],
-    files: readonly string[],
-  ) {
-    super(
-      {
-        name: "linted/scope:svelte",
-        processor: "svelte/svelte",
-        files,
-        plugins,
-        linterOptions: {
-          noInlineConfig: true,
-          reportUnusedDisableDirectives: "error",
-        },
-        languageOptions: {
-          ecmaVersion: "latest",
-          sourceType: "module",
-          parser: svelteParser,
-          parserOptions: {
-            ecmaVersion: "latest",
-            sourceType: "module",
-            project: "tsconfig.json",
-            extraFileExtensions: [".svelte"],
-            parser: tsParser,
-          },
-        },
+  public readonly name = "scope:svelte";
+  public readonly processor = { processor: "svelte/svelte" } as const;
+
+  public get languageOptions() {
+    const [parser, tsParser] = this.parser;
+
+    return {
+      ecmaVersion: "latest",
+      sourceType: "module",
+      parser,
+      parserOptions: {
+        ecmaVersion: "latest",
+        sourceType: "module",
+        project: "tsconfig.json",
+        extraFileExtensions: [".svelte"] as const,
+        parser: tsParser,
       },
-    );
+    } as const;
   }
 }

package/src/factory/options/option/ts/index.ts

@@ -1,38 +1,29 @@
-import Option from "../index.js";
+import Option from "../Option.js";
 import type JsOption from "../js/index.js";
 
 export default class TsOption extends Option<
   "ts",
-  "@typescript-eslint" | keyof JsOption["body"]["plugins"],
+  "@typescript-eslint" | keyof JsOption["option"]["plugins"],
   true,
-  & JsOption["body"]["languageOptions"]
-  & { project: "tsconfig.json" }
+  & JsOption["option"]["languageOptions"]
+  & { project: "tsconfig.json" },
+  1
 > {
-  constructor(
-    plugins: TsOption["body"]["plugins"],
-    parser: unknown,
-    files: readonly string[],
-  ) {
-    super(
-      {
-        name: "linted/scope:ts",
-        files,
-        plugins,
-        linterOptions: {
-          noInlineConfig: true,
-          reportUnusedDisableDirectives: "error",
-        },
-        languageOptions: {
-          ecmaVersion: "latest",
-          sourceType: "module",
-          parser,
-          parserOptions: {
-            ecmaVersion: "latest",
-            sourceType: "module",
-            project: "tsconfig.json",
-          },
-        },
+  public readonly name = "scope:ts";
+  public readonly processor = {} as const;
+
+  public get languageOptions() {
+    const [parser] = this.parser;
+
+    return {
+      ecmaVersion: "latest",
+      sourceType: "module",
+      parser,
+      parserOptions: {
+        ecmaVersion: "latest",
+        sourceType: "module",
+        project: "tsconfig.json",
       },
-    );
+    } as const;
   }
 }

package/src/factory/options/option/yml/index.ts

@@ -1,31 +1,18 @@
-import Option from "../index.js";
+import Option from "../Option.js";
 
 export default class YmlOption extends Option<
   "yml",
   "yml",
+  false,
   true,
-  never,
-  never,
-  never,
-  never,
-  never
+  1
 > {
-  constructor(
-    plugins: YmlOption["body"]["plugins"],
-    parser: YmlOption["body"]["languageOptions"]["parser"],
-    files: readonly string[],
-  ) {
-    super(
-      {
-        name: "linted/scope:yml",
-        files,
-        plugins,
-        linterOptions: {
-          noInlineConfig: true,
-          reportUnusedDisableDirectives: "error",
-        },
-        languageOptions: { parser },
-      },
-    );
+  public readonly name = "scope:yml";
+  public readonly processor = {} as const;
+
+  public get languageOptions() {
+    const [parser] = this.parser;
+
+    return { parser } as const;
   }
 }

package/src/factory/ruleset/{index.ts → Ruleset.ts}

@@ -1,4 +1,4 @@
-import Rule from "./rule/index.js";
+import Rule from "./rule/Rule.js";
 
 export { Rule };
 export default class Ruleset<Language extends string> {

package/src/index.ts

@@ -1,19 +1,19 @@
-import scopes from "./module/index.js";
-import {
-  options,
-  Files,
-  Ruleset,
-  Rule,
-} from "./factory/index.js";
+import scopes from "./boundary/boundary.js";
 import type {
   Scope,
   Plugins,
   Parsers,
-} from "./module/index.js";
-import type Config from "./config/index.js";
+  Config,
+} from "./boundary/boundary.js";
+import {
+  Options,
+  Files,
+  Ruleset,
+  Rule,
+} from "./factory/Factory.js";
 
-export { Ruleset, Rule };
 export type { Scope };
+export { Ruleset, Rule };
 export default function (
   plugins: Plugins,
   parsers: Parsers,
@@ -23,97 +23,87 @@ export default function (
   overrides: Particord<Scope, IRule>,
 ): Config[] {
   try {
+    const files = new Files(
+      base,
+      includes,
+    ),
+          imports: {
+            [S in Scope]: OmitFirst<ConstructorParameters<typeof Options[S]>>;
+          } = {
+            js: [plugins.js, []] as const,
+            ts: [plugins.ts, [parsers.ts]] as const,
+            svelte: [
+              plugins.svelte,
+              [parsers.svelte, parsers.ts],
+            ] as const,
+            html: [plugins.html, [parsers.html]] as const,
+            json: [plugins.json, [parsers.json]] as const,
+            jsonc: [plugins.jsonc, [parsers.jsonc]] as const,
+            yml: [plugins.yml, [parsers.yml]] as const,
+          } as const;
+
     for (const scope of scopes)
       rulesets[scope].override(overrides[scope]);
 
-    const instantiatedOptions: {
+    const options: {
       [S in Scope]: InstanceType<
-        typeof options[S]
-      >["body"]
+        typeof Options[S]
+      >["option"]
     } = {
-      js: new options
+      js: new Options
         .js(
-          plugins.js,
-          new Files(
-            "js",
-            { base, includes },
-          ).files,
-
+          files.files("js"),
+          ...imports.js,
         )
-        .body,
-      ts: new options
+        .option,
+      ts: new Options
         .ts(
-          plugins.ts,
-          parsers.ts,
-          new Files(
-            "ts",
-            { base, includes },
-          ).files,
+          files.files("ts"),
+          ...imports.ts,
         )
-        .body,
-      svelte: new options
+        .option,
+      svelte: new Options
         .svelte(
-          plugins.svelte,
-          parsers.svelte,
-          parsers.ts,
-          new Files(
-            "svelte",
-            { base, includes },
-          ).files,
+          files.files("svelte"),
+          ...imports.svelte,
         )
-        .body,
-      html: new options
+        .option,
+      html: new Options
         .html(
-          plugins.html,
-          parsers.html,
-          new Files(
-            "html",
-            { base, includes },
-          ).files,
+          files.files("html"),
+          ...imports.html,
         )
-        .body,
-      json: new options
+        .option,
+      json: new Options
         .json(
-          plugins.json,
-          parsers.json,
-          new Files(
-            "json",
-            { base, includes },
-          ).files,
+          files.files("json"),
+          ...imports.json,
         )
-        .body,
-      jsonc: new options
+        .option,
+      jsonc: new Options
         .jsonc(
-          plugins.jsonc,
-          parsers.jsonc,
-          new Files(
-            "jsonc",
-            { base, includes },
-          ).files,
+          files.files("jsonc"),
+          ...imports.jsonc,
         )
-        .body,
-      yml: new options
+        .option,
+      yml: new Options
         .yml(
-          plugins.yml,
-          parsers.yml,
-          new Files(
-            "yml",
-            { base, includes },
-          ).files,
+          files.files("yml"),
+          ...imports.yml,
         )
-        .body,
+        .option,
     };
 
     return scopes
       .map(
-        scope => instantiatedOptions[scope].files.length > 0
+        scope => options[scope].files.length > 0
           ? rulesets[scope]
             .flat
             .map(
               rules => {
                 return {
                   rules,
-                  ...instantiatedOptions[scope],
+                  ...options[scope],
                 };
               },
             )

package/types/project/OmitLast.d.ts

@@ -0,0 +1 @@
+declare type OmitFirst<A> = A extends readonly [unknown, ...infer An_1] ? An_1 : never;

package/src/config/files/IFiles.d.ts

@@ -1 +0,0 @@
-declare interface IFiles { files: readonly string[] }

package/src/config/option/IOption.d.ts

@@ -1,25 +0,0 @@
-declare type IOption<
-  Name extends string,
-  NoInline extends boolean,
-  ReportUnused extends boolean | IOLinter.States,
-  PluginId extends string,
-  Ecma extends number | IOLanguageEcma.Ecma,
-  Source extends IOLanguageSource.Source,
-  UseParser extends boolean,
-  ParserOptions extends object,
-  GlobalTypes extends string,
-  ProcessorId extends string,
-> =
-  & IFiles
-  & IOName<Name>
-  & IOLinter<NoInline, ReportUnused>
-  & IOPlugins<PluginId>
-  & IOLanguage<
-    Ecma,
-    Source,
-    UseParser,
-    ParserOptions,
-    GlobalTypes
-  >
-  & IOProcessor<ProcessorId>
-;

package/src/config/option/language/IOLanguage.d.ts

@@ -1,15 +0,0 @@
-declare type IOLanguage<
-  Ecma extends number | IOLanguageEcma.Ecma,
-  Source extends IOLanguageSource.Source,
-  UseParser extends boolean,
-  ParserOptions extends object,
-  GlobalTypes extends string,
-> = {
-  languageOptions:
-    & IOLanguageEcma<Ecma>
-    & IOLanguageSource<Source>
-    & IOLanguageGlobals<GlobalTypes>
-    & IOLanguageParser<UseParser>
-    & IOLanguageParserOptions<ParserOptions>
-  ;
-};