@eslinted/core 8.0.0-rc.0 → 9.0.0-rc.1

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

@@ -1,91 +1,91 @@
-import globals from "globals";
-import type { Ruleset } from "../../rulesets/ruleset";
-import type {
-  Scope,
-  Input,
-  Output,
-  OptionTemplate,
-  LanguageOptions,
-  Plugins,
-  Globals,
-} from "./template";
-
-export default abstract class Option<
-  S extends Scope,
-  Plugin extends keyof Input["plugins"],
-  IsEcma extends boolean = true,
-  ParserOptions extends object | boolean = false,
-  ParserCount extends 0 | 1 | 2 = 0,
-  Global extends Globals = never,
-  Processor extends object = never,
-> {
-  private readonly linterOptions = { noInlineConfig: true, reportUnusedDisableDirectives: "error" } as const;
-
-  public abstract readonly scope: literalful<S>;
-  public abstract readonly processor: Interface<Processor> extends never
-    ? object
-    : Interface<Processor> extends Readonly<Record<"processor", string>>
-      ? Interface<Processor>
-      : object;
-
-  constructor(
-    public readonly plugins: Plugins<Plugin>,
-    public readonly parser: Tuple<ParserCount, unknown>,
-    public readonly files: string[],
-    public readonly ruleset: Ruleset,
-  ) {}
-
-  public get configs(): Output {
-    const {
-      scope,
-      ruleset,
-      files,
-      option,
-    } = this;
-
-    if (ruleset.scope !== scope)
-      throw new TypeError(`Scope mismatch between option and ruleset`, { cause: { option: scope, ruleset: ruleset.scope } });
-
-    return files.length < 1
-      ? []
-      : ruleset.ruleset.map(({ id, rule }) => {
-        return {
-          name: `linted/${id}`,
-          files,
-          rules: rule,
-          ...option,
-        };
-      });
-  }
-
-  private get option() {
-    try {
-      const {
-        plugins,
-        linterOptions,
-        languageOptions,
-        processor,
-      } = this;
-
-      return {
-        plugins,
-        linterOptions,
-        languageOptions,
-        ...processor,
-      } satisfies OptionTemplate<
-        Plugin,
-        IsEcma,
-        ParserOptions,
-        Global,
-        Processor
-      >;
-    }
-    catch (e) { throw new Error(`linted.factory.Option/scope:${this.scope}: option`, { cause: e }); }
-  }
-
-  protected abstract get languageOptions(): LanguageOptions<IsEcma, ParserOptions, Global>;
-
-  protected globals(type: Global) {
-    return globals[type];
-  }
-}
+import globals from "globals";
+import type { Ruleset } from "../../rulesets/ruleset";
+import type {
+  Scope,
+  Input,
+  Output,
+  OptionTemplate,
+  LanguageOptions,
+  Plugins,
+  Globals,
+} from "./template";
+
+export default abstract class Option<
+  S extends Scope,
+  Plugin extends keyof Input["plugins"],
+  IsEcma extends boolean = true,
+  ParserOptions extends object | boolean = false,
+  ParserCount extends 0 | 1 | 2 = 0,
+  Global extends Globals = never,
+  Processor extends object = never,
+> {
+  private readonly linterOptions = { noInlineConfig: true, reportUnusedDisableDirectives: "error" } as const;
+
+  public abstract readonly scope: literalful<S>;
+  public abstract readonly processor: Interface<Processor> extends never
+    ? object
+    : Interface<Processor> extends Readonly<Record<"processor", string>>
+      ? Interface<Processor>
+      : object;
+
+  constructor(
+    public readonly plugins: Plugins<Plugin>,
+    public readonly parser: Tuple<ParserCount, unknown>,
+    public readonly files: string[],
+    public readonly ruleset: Ruleset,
+  ) {}
+
+  public get configs(): Output {
+    const {
+      scope,
+      ruleset,
+      files,
+      option,
+    } = this;
+
+    if (ruleset.scope !== scope)
+      throw new TypeError(`Scope mismatch between option and ruleset`, { cause: { option: scope, ruleset: ruleset.scope } });
+
+    return files.length < 1
+      ? []
+      : ruleset.ruleset.map(({ id, rule }) => {
+        return {
+          name: `linted/${id}`,
+          files,
+          rules: rule,
+          ...option,
+        };
+      });
+  }
+
+  private get option() {
+    try {
+      const {
+        plugins,
+        linterOptions,
+        languageOptions,
+        processor,
+      } = this;
+
+      return {
+        plugins,
+        linterOptions,
+        languageOptions,
+        ...processor,
+      } satisfies OptionTemplate<
+        Plugin,
+        IsEcma,
+        ParserOptions,
+        Global,
+        Processor
+      >;
+    }
+    catch (e) { throw new Error(`linted.factory.Option/scope:${this.scope}: option`, { cause: e }); }
+  }
+
+  protected abstract get languageOptions(): LanguageOptions<IsEcma, ParserOptions, Global>;
+
+  protected globals(type: Global) {
+    return globals[type];
+  }
+}

package/src/factory/options/option/template/globals.ts

@@ -1,5 +1,5 @@
-import type globals from "globals";
-
-export type Globals = keyof typeof globals & (
-  | "mocha"
-);
+import type globals from "globals";
+
+export type Globals = keyof typeof globals & (
+  | "mocha"
+);

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

@@ -1,26 +1,26 @@
-export type { Scope, Input, Output } from "../..";
-
-import type { LanguageOptions } from "./language";
-import type { Linter } from "./linter";
-import type { Plugins } from "./plugins";
-import type { Globals } from "./globals";
-
-export type {
-  LanguageOptions,
-  Linter,
-  Plugins,
-  Globals,
-};
-export type OptionTemplate<
-  PluginId extends string,
-  IsEcma extends boolean,
-  ParserOptions extends boolean | object,
-  GlobalTypes extends Globals,
-  Processor extends object,
-> =
-  & {
-    linterOptions: Linter;
-    languageOptions: LanguageOptions<IsEcma, ParserOptions, GlobalTypes>;
-  }
-  & (Plugins<PluginId> extends never ? object : { plugins: Plugins<PluginId> })
-  & (Interface<Processor> extends never ? object : Interface<Processor> extends { processor: string } ? Interface<Processor> : object);
+export type { Scope, Input, Output } from "../..";
+
+import type { LanguageOptions } from "./language";
+import type { Linter } from "./linter";
+import type { Plugins } from "./plugins";
+import type { Globals } from "./globals";
+
+export type {
+  LanguageOptions,
+  Linter,
+  Plugins,
+  Globals,
+};
+export type OptionTemplate<
+  PluginId extends string,
+  IsEcma extends boolean,
+  ParserOptions extends boolean | object,
+  GlobalTypes extends Globals,
+  Processor extends object,
+> =
+  & {
+    linterOptions: Linter;
+    languageOptions: LanguageOptions<IsEcma, ParserOptions, GlobalTypes>;
+  }
+  & (Plugins<PluginId> extends never ? object : { plugins: Plugins<PluginId> })
+  & (Interface<Processor> extends never ? object : Interface<Processor> extends { processor: string } ? Interface<Processor> : object);

package/src/factory/options/option/template/language/ecma.ts

@@ -1,3 +1,3 @@
-export type EcmaVersion = (
-  | "latest"
-);
+export type EcmaVersion = (
+  | "latest"
+);

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

@@ -1,21 +1,21 @@
-import type { EcmaVersion } from "./ecma";
-import type { SourceType } from "./source";
-
-export type LanguageOptions<
-  IsEcma extends boolean,
-  ParserOptions extends object | boolean,
-  GlobalTypes extends string,
-> =
- & (True<IsEcma> extends never ? object : { ecmaVersion: EcmaVersion; sourceType: SourceType })
- & (literalful<GlobalTypes> extends never ? object : { globals: Record<string, unknown> })
- & (
-    ParserOptions extends boolean
-      ? True<ParserOptions> extends never
-        ? object
-        : { parser: unknown }
-      : ParserOptions extends object
-        ? Interface<ParserOptions> extends never
-          ? object
-          : { parser: unknown; parserOptions: ParserOptions }
-        : object
-  );
+import type { EcmaVersion } from "./ecma";
+import type { SourceType } from "./source";
+
+export type LanguageOptions<
+  IsEcma extends boolean,
+  ParserOptions extends object | boolean,
+  GlobalTypes extends string,
+> =
+ & (True<IsEcma> extends never ? object : { ecmaVersion: EcmaVersion; sourceType: SourceType })
+ & (literalful<GlobalTypes> extends never ? object : { globals: Record<string, unknown> })
+ & (
+    ParserOptions extends boolean
+      ? True<ParserOptions> extends never
+        ? object
+        : { parser: unknown }
+      : ParserOptions extends object
+        ? Interface<ParserOptions> extends never
+          ? object
+          : { parser: unknown; parserOptions: ParserOptions }
+        : object
+  );

package/src/factory/options/option/template/language/source.ts

@@ -1,4 +1,4 @@
-export type SourceType = (
-  | "module"
-  | "script"
-);
+export type SourceType = (
+  | "module"
+  | "script"
+);

package/src/factory/options/option/template/linter.ts

@@ -1,8 +1,8 @@
-export interface Linter {
-  noInlineConfig: boolean;
-  reportUnusedDisableDirectives:
-    | "error"
-    | "warn"
-    | "off"
-  ;
-}
+export interface Linter {
+  noInlineConfig: boolean;
+  reportUnusedDisableDirectives:
+    | "error"
+    | "warn"
+    | "off"
+  ;
+}

package/src/factory/options/option/template/plugins.ts

@@ -1 +1 @@
-export type Plugins<PluginId extends string> = Record<literalful<PluginId>, { configs: unknown }>;
+export type Plugins<PluginId extends string> = Record<literalful<PluginId>, { configs: unknown }>;

package/src/factory/options/svelte.ts

@@ -1,32 +1,32 @@
-import Option from "./option";
-import type Ts from "./ts";
-
-export default class Svelte extends Option<
-  "svelte",
-  "svelte" | keyof Ts["option"]["plugins"],
-  true,
-  { parser: unknown } & { extraFileExtensions: readonly [".svelte"] } & Ts["option"]["languageOptions"]["parserOptions"],
-  2,
-  never,
-  { processor: "svelte/svelte" }
-> {
-  public readonly 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: {
-        parser: tsParser,
-        extraFileExtensions: [".svelte"] as const,
-        project: "tsconfig.json",
-        ecmaVersion: "latest",
-        sourceType: "module",
-      },
-    } as const;
-  }
-}
+import Option from "./option";
+import type Ts from "./ts";
+
+export default class Svelte extends Option<
+  "svelte",
+  "svelte" | keyof Ts["option"]["plugins"],
+  true,
+  { parser: unknown } & { extraFileExtensions: readonly [".svelte"] } & Ts["option"]["languageOptions"]["parserOptions"],
+  2,
+  never,
+  { processor: "svelte/svelte" }
+> {
+  public readonly 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: {
+        parser: tsParser,
+        extraFileExtensions: [".svelte"] as const,
+        project: "tsconfig.json",
+        ecmaVersion: "latest",
+        sourceType: "module",
+      },
+    } as const;
+  }
+}

package/src/factory/options/ts.ts

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

package/src/factory/options/yml.ts

@@ -1,18 +1,18 @@
-import Option from "./option";
-
-export default class Yml extends Option<
-  "yml",
-  "yml",
-  false,
-  true,
-  1
-> {
-  public readonly scope = "yml";
-  public readonly processor = {} as const;
-
-  public get languageOptions() {
-    const [parser] = this.parser;
-
-    return { parser } as const;
-  }
-}
+import Option from "./option";
+
+export default class Yml extends Option<
+  "yml",
+  "yml",
+  false,
+  true,
+  1
+> {
+  public readonly scope = "yml";
+  public readonly processor = {} as const;
+
+  public get languageOptions() {
+    const [parser] = this.parser;
+
+    return { parser } as const;
+  }
+}

package/src/factory/rulesets/index.ts

@@ -1,24 +1,24 @@
-import type { Input } from "..";
-
-export type { Input };
-
-import { Ruleset } from "./ruleset";
-
-export class Rulesets {
-  private readonly rulesets = new Map<string, Ruleset>();
-
-  constructor(rules: Input["rules"]) {
-    const { rules: base, overrides } = rules,
-    scopes = Object.keys(base) as (keyof typeof base)[];
-
-    for (const scope of scopes)
-      this.rulesets.set(scope, new Ruleset(scope, base[scope], overrides[scope]));
-  }
-
-  public ruleset(scope: string): Ruleset {
-    if (!this.rulesets.has(scope))
-      throw new ReferenceError(`Ruleset not found for scope: ${scope}`);
-
-    return this.rulesets.get(scope) as Ruleset;
-  }
-}
+import type { Input } from "..";
+
+export type { Input };
+
+import { Ruleset } from "./ruleset";
+
+export class Rulesets {
+  private readonly rulesets = new Map<string, Ruleset>();
+
+  constructor(rules: Input["rules"]) {
+    const { rules: base, overrides } = rules,
+    scopes = Object.keys(base) as (keyof typeof base)[];
+
+    for (const scope of scopes)
+      this.rulesets.set(scope, new Ruleset(scope, base[scope], overrides[scope]));
+  }
+
+  public ruleset(scope: string): Ruleset {
+    if (!this.rulesets.has(scope))
+      throw new ReferenceError(`Ruleset not found for scope: ${scope}`);
+
+    return this.rulesets.get(scope) as Ruleset;
+  }
+}

package/src/factory/rulesets/ruleset.ts

@@ -1,25 +1,25 @@
-import type { Input } from ".";
-
-export class Ruleset {
-  public readonly ruleset: { id: string; rule: Input.Rule.Entry.Record }[];
-
-  constructor(
-    public readonly scope: string,
-    rules: (readonly [string, Input.Rule.Entry.Record])[],
-    override?: Input.Rule.Entry.Record,
-  ) {
-    const map = ([id, rule]: typeof rules[number]) => {
-      return {
-        id: `${scope}:${id}`,
-        rule,
-      };
-    };
-
-    this.ruleset = [
-      ...rules.map(rule => map(rule)),
-      ...typeof override === "undefined"
-        ? []
-        : [map([`${scope}:override`, override])],
-    ];
-  }
-}
+import type { Input } from ".";
+
+export class Ruleset {
+  public readonly ruleset: { id: string; rule: Input.Rule.Entry.Record }[];
+
+  constructor(
+    public readonly scope: string,
+    rules: (readonly [string, Input.Rule.Entry.Record])[],
+    override?: Input.Rule.Entry.Record,
+  ) {
+    const map = ([id, rule]: typeof rules[number]) => {
+      return {
+        id: `${scope}:${id}`,
+        rule,
+      };
+    };
+
+    this.ruleset = [
+      ...rules.map(rule => map(rule)),
+      ...typeof override === "undefined"
+        ? []
+        : [map([`${scope}:override`, override])],
+    ];
+  }
+}