@eslinted/core 13.3.0-rc.1 → 13.3.0-rc.2

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

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

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

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

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

@@ -1,17 +1,11 @@
 import { ScopeSetting } from "../setting";
 
 export default class YmlSetting extends ScopeSetting<
-  "yml",
-  true,
-  1
+  "yml"
 > {
   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;
-  }
+  public readonly parserOptions = {} as const;
+  public readonly languageOptions = { parser: "yml" } as const;
 }

package/src/factory/settings/setting.ts

@@ -2,61 +2,57 @@ import 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 | false = false,
+  Parser extends Scopes | false = false,
+  ParserOptions extends object = object,
+  Global extends keyof typeof globals | 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 abstract readonly scope: Scopes;
+  public abstract readonly processor: (Processor extends { readonly processor: infer P }
+    ? string extends P
+      ? Record<string, never>
+      : { readonly processor: P }
+    : Record<string, never>);
+  public abstract readonly language: (Language extends { readonly language: infer L }
+    ? string extends L
+      ? Record<string, never>
+      : { readonly language: L }
+    : Record<string, never>);
+  public abstract readonly parserOptions: (ParserOptions extends { readonly parserOptions: infer PO }
+    ? PO extends { readonly parser: infer P }
+      ? P extends Parser
+        ? ParserOptions
+        : Record<string, never>
+      : ParserOptions
+    : Record<string, never>);
+  public abstract readonly languageOptions: (
+    [Parser] extends [boolean]
+      ? { readonly parser?: never }
+      : { parser: Parser }
+
+  ) & (
+    Global extends boolean
+      ? { readonly globals?: never }
+      : { readonly globals: Readonly<Record<string, unknown>> }
+  );
 
   public get option() {
-    const { languageOptions, processor, language } = this;
+    const {
+      languageOptions, parserOptions, processor, language,
+    } = this;
 
     return {
-      languageOptions,
+      languageOptions: {
+        ...languageOptions,
+        ...parserOptions,
+      },
       ...processor,
       ...language,
     } as const;
   }
 
-  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 };
-
-  protected globals(global: G & keyof typeof globals) {
+  protected globals(global: Global & keyof typeof globals) {
     if (typeof global === "boolean")
       throw new TypeError("`global` must be a string key of `globals` package");
 

package/src/index.ts

@@ -10,16 +10,16 @@ export default function ({
   extensions,
 }: Input): Output {
   try {
-    const factory = new Factory(defaults, extensions),
+    const factory = new Factory(parsers, defaults, extensions),
     options: { readonly [S in typeof scopes[number]]: InstanceType<typeof ScopeSettings[S]> } = {
-      js: new ScopeSettings.js([] as const),
-      ts: new ScopeSettings.ts([parsers.ts] as const),
-      svelte: new ScopeSettings.svelte([parsers.svelte, parsers.ts] as const),
-      mocha: new ScopeSettings.mocha([parsers.ts] as const),
-      html: new ScopeSettings.html([parsers.html] as const),
-      json: new ScopeSettings.json([parsers.jsonc] as const),
-      jsonc: new ScopeSettings.jsonc([parsers.jsonc] as const),
-      yml: new ScopeSettings.yml([parsers.yml] as const),
+      js: new ScopeSettings.js(),
+      ts: new ScopeSettings.ts(),
+      svelte: new ScopeSettings.svelte(),
+      mocha: new ScopeSettings.mocha(),
+      html: new ScopeSettings.html(),
+      json: new ScopeSettings.json(),
+      jsonc: new ScopeSettings.jsonc(),
+      yml: new ScopeSettings.yml(),
     } as const;
 
     return [