@eslinted/core 3.0.3-rc.2 → 3.0.3

package/src/boundary/index.ts

@@ -0,0 +1,4 @@
+import type Output from "./output/index.js";
+
+export type * as Input from "./input/index.js";
+export type { Output };

package/src/boundary/input/files/base/index.ts

@@ -0,0 +1,5 @@
+import type { Scope } from "../../../../scopes/index.js";
+
+type Base = Readonly<Record<Scope, readonly string[]>>;
+
+export type { Base, Base as default };

package/src/boundary/input/files/includes/index.ts

@@ -0,0 +1,5 @@
+import type * as Includes from "../base/index.js";
+
+type Includes = Partial<Includes.Base>;
+
+export type { Includes, Includes as default };

package/src/boundary/input/files/index.ts

@@ -0,0 +1,4 @@
+import type Base from "./base/index.js";
+import type Includes from "./includes/index.js";
+
+export type { Base, Includes };

package/src/boundary/input/index.ts

@@ -0,0 +1,6 @@
+import type Plugins from "./plugins/index.js";
+import type Parsers from "./parsers/index.js";
+
+export type { Plugins, Parsers };
+export type * as Files from "./files/index.js";
+export type * as Rules from "./rules/index.js";

package/src/boundary/input/parsers/{parsers.ts → index.ts}

@@ -1,9 +1,5 @@
-import type { Parsers as Dependencies } from "../../../dependency/dependency.js";
+import type { Parsers as Dependencies } from "../../../dependency/index.js";
 
 type Parsers = Readonly<Record<Dependencies, unknown>>;
 
-export type {
-  Parsers as default,
-  Parsers,
-  Dependencies,
-};
+export type { Dependencies, Parsers, Parsers as default };

package/src/boundary/input/plugins/{plugins.ts → index.ts}

@@ -1,9 +1,5 @@
-import type { Plugins as Dependencies } from "../../../dependency/dependency.js";
+import type { Plugins as Dependencies } from "../../../dependency/index.js";
 
 type Plugins = Readonly<Record<Dependencies, { configs: unknown }>>;
 
-export type {
-  Plugins as default,
-  Plugins,
-  Dependencies,
-};
+export type { Dependencies, Plugins, Plugins as default };

package/src/boundary/input/rules/index.ts

@@ -0,0 +1,4 @@
+import type Preset from "./preset/index.js";
+import type Overrides from "./overrides/index.js";
+
+export type { Preset, Overrides };

package/src/boundary/input/rules/overrides/index.ts

@@ -0,0 +1,6 @@
+import type { Scope } from "../../../../scopes/index.js";
+import type * as Overrides from "../preset/index.js";
+
+type Overrides = Readonly<Partial<Record<Scope, Overrides.Preset.Entry.Object>>>;
+
+export type { Overrides, Overrides as default };

package/src/boundary/input/rules/preset/entry/index.ts

@@ -0,0 +1,5 @@
+import type * as Entry from "./object/index.js";
+
+type Entry = readonly [string, Entry.Object];
+
+export type { Entry, Entry as default };

package/src/boundary/input/rules/preset/entry/object/index.ts

@@ -0,0 +1,9 @@
+import type * as Object from "./state/index.js";
+
+type Object = Readonly<Record<
+  string,
+  | Object.Level
+  | readonly [Object.Level, ...unknown[]]
+>>;
+
+export type { Object, Object as default };

package/src/boundary/input/rules/preset/entry/object/state/index.ts

@@ -0,0 +1,6 @@
+type Level =
+  | "error"
+  | "warn"
+  | "off";
+
+export type { Level, Level as default };

package/src/boundary/input/rules/preset/index.ts

@@ -0,0 +1,6 @@
+import type { Scope } from "../../../../scopes/index.js";
+import type * as Preset from "./entry/index.js";
+
+type Preset = Readonly<Record<Scope, readonly Preset.Entry[]>>;
+
+export type { Preset, Preset as default };

package/src/boundary/output/config/{config.ts → index.ts}

@@ -1,4 +1,4 @@
-import type { Rules } from "../../input/input.js";
+import type { Rules } from "../../input/index.js";
 
 export default interface Config {
   name: `linted/scope:${string}/rule:${string}+${string}`;

package/src/boundary/output/index.ts

@@ -0,0 +1,3 @@
+import type Config from "./config/index.js";
+
+export type { Config as default };

package/src/dependency/{dependency.ts → index.ts}

@@ -2,8 +2,4 @@ import type Plugins from "./plugins/index.js";
 import type Parsers from "./parsers/index.js";
 import type Globals from "./globals/index.js";
 
-export type {
-  Plugins,
-  Parsers,
-  Globals,
-};
+export type { Plugins, Parsers, Globals };

package/src/dependency/parsers/index.ts

@@ -1,4 +1,4 @@
-import type { Scope } from "../../scopes/Scopes.js";
+import type { Scope } from "../../scopes/index.js";
 
 type Parsers =
   | "ts"

package/src/factory/files/index.ts

@@ -0,0 +1,16 @@
+import type { Scope } from "../../scopes/index.js";
+import type { Input } from "../../boundary/index.js";
+
+export default class Files {
+  constructor(
+    private readonly base: Input.Files.Base,
+    private readonly includes: Input.Files.Includes,
+  ) {}
+
+  public files(scope: Scope): readonly string[] {
+    try {
+      return [...this.base[scope], ...this.includes[scope] ?? []];
+    }
+    catch (e) { throw new Error(`linted.factory.Files/scope:${scope}`, { cause: e }); }
+  }
+}

package/src/factory/index.ts

@@ -0,0 +1,10 @@
+import Ruleset, { Rule } from "./ruleset/index.js";
+import Files from "./files/index.js";
+import Options from "./options/index.js";
+
+export {
+  Options,
+  Files,
+  Ruleset,
+  Rule,
+};

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

@@ -1,4 +1,4 @@
-import Option from "../Option.js";
+import Option from "../index.js";
 
 export default class Html extends Option<
   "html",
@@ -11,16 +11,8 @@ export default class Html extends Option<
   public readonly processor = {} as const;
 
   public get languageOptions() {
-    try {
-      const [parser] = this.parser;
+    const [parser] = this.parser;
 
-      return { parser } as const;
-    }
-    catch (e) {
-      throw new Error(
-        `linted.factory.options.html: languageOptions`,
-        { cause: e },
-      );
-    }
+    return { parser } as const;
   }
 }

package/src/factory/options/option/{Option.ts → index.ts}

@@ -1,8 +1,8 @@
 import globals from "globals";
-import type { Scope } from "../../../scopes/Scopes.js";
-import type { Ruleset } from "../../factory.js";
-import type { Plugins } from "../../../dependency/dependency.js";
-import type { Output } from "../../../boundary/boundary.js";
+import type { Scope } from "../../../scopes/index.js";
+import type { Ruleset } from "../../index.js";
+import type { Plugins } from "../../../dependency/index.js";
+import type { Output } from "../../../boundary/index.js";
 
 export default abstract class Option<
   S extends Scope,
@@ -13,10 +13,7 @@ export default abstract class Option<
   GlobalTypes extends keyof typeof globals = never,
   Processor extends object = never,
 > {
-  private readonly linterOptions = {
-    noInlineConfig: true,
-    reportUnusedDisableDirectives: "error",
-  } as const;
+  private readonly linterOptions = { noInlineConfig: true, reportUnusedDisableDirectives: "error" } as const;
 
   public abstract readonly scope: literalful<S>;
   public abstract readonly processor: Interface<Processor> extends never
@@ -42,35 +39,25 @@ export default abstract class Option<
       } = this;
 
       if (ruleset.id !== scope)
-        throw new TypeError(
-          `Option and Ruleset scope mismatch`,
-          { cause: { option: scope, ruleset: ruleset.id } },
-        );
+        throw new TypeError(`Option and Ruleset scope mismatch`, { cause: { option: scope, ruleset: ruleset.id } });
       else if (files.length < 1)
         return [];
       else {
         const baseName = `linted/scope:${scope}/rule:${ruleset.id}` as const;
 
-        return ruleset.records.map(
-          ([ruleId, rules]) => {
-            const name = `${baseName}+${ruleId}` as const;
+        return ruleset.records.map(([ruleId, rules]) => {
+          const name = `${baseName}+${ruleId}` as const;
 
-            return {
-              name,
-              files,
-              rules,
-              ...option,
-            };
-          },
-        );
+          return {
+            name,
+            files,
+            rules,
+            ...option,
+          };
+        });
       }
     }
-    catch (e) {
-      throw new Error(
-        `linted.factory.Option/scope:${this.scope}: configs`,
-        { cause: e },
-      );
-    }
+    catch (e) { throw new Error(`linted.factory.Option/scope:${this.scope}: configs`, { cause: e }); }
   }
 
   private get option() {
@@ -95,29 +82,12 @@ export default abstract class Option<
         Processor
       >;
     }
-    catch (e) {
-      throw new Error(
-        `linted.factory.Option/scope:${this.scope}: option`,
-        { cause: e },
-      );
-    }
+    catch (e) { throw new Error(`linted.factory.Option/scope:${this.scope}: option`, { cause: e }); }
   }
 
-  protected abstract get languageOptions(): IOLanguage<
-    IsEcma,
-    ParserOptions,
-    GlobalTypes
-  >;
+  protected abstract get languageOptions(): IOLanguage<IsEcma, ParserOptions, GlobalTypes>;
 
   protected globals(type: GlobalTypes) {
-    try {
-      return globals[type];
-    }
-    catch (e) {
-      throw new Error(
-        `linted.factory.Option/scope:${this.scope}: globals`,
-        { cause: e },
-      );
-    }
+    return globals[type];
   }
 }

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

@@ -1,21 +1,13 @@
-import Option from "../Option.js";
+import Option from "../index.js";
 
 export default class Js extends Option<"js", "@stylistic"> {
   public readonly scope = "js";
   public readonly processor = {};
 
   public get languageOptions() {
-    try {
-      return {
-        ecmaVersion: "latest",
-        sourceType: "module",
-      } as const;
-    }
-    catch (e) {
-      throw new Error(
-        `linted.factory.options.js: languageOptions`,
-        { cause: e },
-      );
-    }
+    return {
+      ecmaVersion: "latest",
+      sourceType: "module",
+    } as const;
   }
 }

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

@@ -1,4 +1,4 @@
-import Option from "../Option.js";
+import Option from "../index.js";
 
 export default class Json extends Option<
   "json",
@@ -11,16 +11,8 @@ export default class Json extends Option<
   public readonly processor = {} as const;
 
   public get languageOptions() {
-    try {
-      const [parser] = this.parser;
+    const [parser] = this.parser;
 
-      return { parser } as const;
-    }
-    catch (e) {
-      throw new Error(
-        `linted.factory.options.json: languageOptions`,
-        { cause: e },
-      );
-    }
+    return { parser } as const;
   }
 }

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

@@ -1,4 +1,4 @@
-import Option from "../Option.js";
+import Option from "../index.js";
 
 export default class Jsonc extends Option<
   "jsonc",
@@ -11,16 +11,8 @@ export default class Jsonc extends Option<
   public readonly processor = {} as const;
 
   public get languageOptions() {
-    try {
-      const [parser] = this.parser;
+    const [parser] = this.parser;
 
-      return { parser } as const;
-    }
-    catch (e) {
-      throw new Error(
-        `linted.factory.options.jsonc: languageOptions`,
-        { cause: e },
-      );
-    }
+    return { parser } as const;
   }
 }

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

@@ -1,4 +1,4 @@
-import Option from "../Option.js";
+import Option from "../index.js";
 
 export default class Md extends Option<
   "md",
@@ -11,16 +11,8 @@ export default class Md extends Option<
   public readonly processor = {} as const;
 
   public get languageOptions() {
-    try {
-      const [parser] = this.parser;
+    const [parser] = this.parser;
 
-      return { parser } as const;
-    }
-    catch (e) {
-      throw new Error(
-        `linted.factory.options.md: languageOptions`,
-        { cause: e },
-      );
-    }
+    return { parser } as const;
   }
 }

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

@@ -1,11 +1,11 @@
-import Option from "../Option.js";
+import Option from "../index.js";
 import type Ts from "../ts/index.js";
 
 export default class Mocha extends Option<
   "mocha",
   "mocha" | keyof Ts["option"]["plugins"],
   true,
-  & Ts["option"]["languageOptions"]["parserOptions"],
+  Ts["option"]["languageOptions"]["parserOptions"],
   1,
   "mocha"
 > {
@@ -14,27 +14,15 @@ export default class Mocha extends Option<
   public readonly types = ["mocha"] as const;
 
   public get languageOptions() {
-    try {
-      const [parser] = this.parser,
-      globals = this.globals("mocha");
+    const [parser] = this.parser,
+    globals = this.globals("mocha");
 
-      return {
-        ecmaVersion: "latest",
-        sourceType: "module",
-        parser,
-        parserOptions: {
-          ecmaVersion: "latest",
-          sourceType: "module",
-          project: "tsconfig.json",
-        },
-        globals,
-      } as const;
-    }
-    catch (e) {
-      throw new Error(
-        `linted.factory.options.mocha: languageOptions`,
-        { cause: e },
-      );
-    }
+    return {
+      ecmaVersion: "latest",
+      sourceType: "module",
+      parser,
+      parserOptions: { project: "tsconfig.json", ecmaVersion: "latest", sourceType: "module" },
+      globals,
+    } as const;
   }
 }

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

@@ -1,13 +1,11 @@
-import Option from "../Option.js";
+import Option from "../index.js";
 import type Ts from "../ts/index.js";
 
 export default class Svelte extends Option<
   "svelte",
   "svelte" | keyof Ts["option"]["plugins"],
   true,
-  & Ts["option"]["languageOptions"]["parserOptions"]
-  & { parser: unknown }
-  & { extraFileExtensions: readonly [".svelte"] },
+  { parser: unknown } & { extraFileExtensions: readonly [".svelte"] } & Ts["option"]["languageOptions"]["parserOptions"],
   2,
   never,
   { processor: "svelte/svelte" }
@@ -16,27 +14,19 @@ export default class Svelte extends Option<
   public readonly processor = { processor: "svelte/svelte" } as const;
 
   public get languageOptions() {
-    try {
-      const [parser, tsParser] = this.parser;
+    const [parser, tsParser] = this.parser;
 
-      return {
+    return {
+      ecmaVersion: "latest",
+      sourceType: "module",
+      parser,
+      parserOptions: {
+        parser: tsParser,
+        extraFileExtensions: [".svelte"] as const,
+        project: "tsconfig.json",
         ecmaVersion: "latest",
         sourceType: "module",
-        parser,
-        parserOptions: {
-          ecmaVersion: "latest",
-          sourceType: "module",
-          project: "tsconfig.json",
-          extraFileExtensions: [".svelte"] as const,
-          parser: tsParser,
-        },
-      } as const;
-    }
-    catch (e) {
-      throw new Error(
-        `linted.factory.options.svelte: languageOptions`,
-        { cause: e },
-      );
-    }
+      },
+    } as const;
   }
 }

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

@@ -1,37 +1,24 @@
-import Option from "../Option.js";
+import Option from "../index.js";
 import type Js from "../js/index.js";
 
 export default class Ts extends Option<
   "ts",
   "@typescript-eslint" | keyof Js["option"]["plugins"],
   true,
-  & Js["option"]["languageOptions"]
-  & { project: "tsconfig.json" },
+  { project: "tsconfig.json" } & Js["option"]["languageOptions"],
   1
 > {
   public readonly scope = "ts";
   public readonly processor = {} as const;
 
   public get languageOptions() {
-    try {
-      const [parser] = this.parser;
+    const [parser] = this.parser;
 
-      return {
-        ecmaVersion: "latest",
-        sourceType: "module",
-        parser,
-        parserOptions: {
-          ecmaVersion: "latest",
-          sourceType: "module",
-          project: "tsconfig.json",
-        },
-      } as const;
-    }
-    catch (e) {
-      throw new Error(
-        `linted.factory.options.ts: languageOptions`,
-        { cause: e },
-      );
-    }
+    return {
+      ecmaVersion: "latest",
+      sourceType: "module",
+      parser,
+      parserOptions: { project: "tsconfig.json", ecmaVersion: "latest", sourceType: "module" },
+    } as const;
   }
 }

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

@@ -1,4 +1,4 @@
-import Option from "../Option.js";
+import Option from "../index.js";
 
 export default class Yml extends Option<
   "yml",
@@ -11,16 +11,8 @@ export default class Yml extends Option<
   public readonly processor = {} as const;
 
   public get languageOptions() {
-    try {
-      const [parser] = this.parser;
+    const [parser] = this.parser;
 
-      return { parser } as const;
-    }
-    catch (e) {
-      throw new Error(
-        `linted.factory.options.yml: languageOptions`,
-        { cause: e },
-      );
-    }
+    return { parser } as const;
   }
 }

package/src/factory/ruleset/index.ts

@@ -0,0 +1,40 @@
+import type { Scope } from "../../scopes/index.js";
+import Rule from "./rule/index.js";
+
+export { Rule };
+export default class Ruleset<S extends Scope> {
+  public readonly ruleset: readonly Rule[];
+  public overrides: Null<Rule> = null;
+
+  constructor(private readonly scope: literalful<S>, ...rules: readonly Rule[]) {
+    try {
+      this.ruleset = [...rules];
+    }
+    catch (e) { throw new Error(`linted.factory.Ruleset`, { cause: e }); }
+  }
+
+  public get id() {
+    const { scope } = this;
+
+    return scope;
+  }
+
+  public get records() {
+    try {
+      const { ruleset, overrides } = this;
+
+      return [
+        ...ruleset.map(rules => [rules.id, rules.rules] as const),
+        ...overrides === null ? [] : [[overrides.id, overrides.rules] as const] as const,
+      ];
+    }
+    catch (e) { throw new Error(`linted.factory.Ruleset: records`, { cause: e }); }
+  }
+
+  public override(overrides: undefined | Rule["rules"]) {
+    if (typeof overrides !== "undefined")
+      this.overrides = new Rule("override", overrides);
+
+    return this;
+  }
+}

package/src/factory/ruleset/rule/{Rule.ts → index.ts}

@@ -1,4 +1,4 @@
-import type { Input } from "../../../boundary/boundary.js";
+import type { Input } from "../../../boundary/index.js";
 
 export default class {
   constructor(