@eslinted/core 3.1.12 → 3.1.13-rc.1

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

@@ -1,32 +1,32 @@
-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,
-  { 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 "../index.js";
+import type Ts from "../ts/index.js";
+
+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/option/ts/index.ts

@@ -1,24 +1,24 @@
-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,
-  { 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 "../index.js";
+import type Js from "../js/index.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/option/yml/index.ts

@@ -1,18 +1,18 @@
-import Option from "../index.js";
-
-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 "../index.js";
+
+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,16 +1,16 @@
-import Ruleset, { Rule } from "./ruleset/index.js";
-import type { Input } from "../../boundary/index.js";
-import type { Scope } from "../../scopes/index.js";
-
-export default class {
-  constructor(private readonly input: Input.Rules.Rules) {}
-
-  public ruleset<S extends Scope>(scope: literalful<S>): Ruleset<S> {
-    try {
-      const { preset, overrides } = this.input;
-
-      return new Ruleset<S>(scope, ...preset[scope].map(args => new Rule(...args))).override(overrides[scope]);
-    }
-    catch (e) { throw new Error(`linted.factory.Rulesets/ruleset/scope:${scope}`, { cause: e }); }
-  }
-}
+import Ruleset, { Rule } from "./ruleset/index.js";
+import type { Input } from "../../boundary/index.js";
+import type { Scope } from "../../scopes/index.js";
+
+export default class {
+  constructor(private readonly input: Input.Rules.Rules) {}
+
+  public ruleset<S extends Scope>(scope: literalful<S>): Ruleset<S> {
+    try {
+      const { preset, overrides } = this.input;
+
+      return new Ruleset<S>(scope, ...preset[scope].map(args => new Rule(...args))).override(overrides[scope]);
+    }
+    catch (e) { throw new Error(`linted.factory.Rulesets/ruleset/scope:${scope}`, { cause: e }); }
+  }
+}

package/src/factory/rulesets/ruleset/index.ts

@@ -1,40 +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;
-  }
-}
+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/rulesets/ruleset/rule/index.ts

@@ -1,8 +1,8 @@
-import type { Input } from "../../../../boundary/index.js";
-
-export default class {
-  constructor(
-    public readonly id: string,
-    public readonly rules: Input.Rules.Preset.Entry.Object,
-  ) {}
-}
+import type { Input } from "../../../../boundary/index.js";
+
+export default class {
+  constructor(
+    public readonly id: string,
+    public readonly rules: Input.Rules.Preset.Entry.Object,
+  ) {}
+}

package/src/index.ts

@@ -1,95 +1,95 @@
-import scopes, { type Scope } from "./scopes/index.js";
-import type * as Boundary from "./boundary/index.js";
-import { Options, Files, Rulesets } from "./factory/index.js";
-
-export type { Boundary };
-export default function (
-  plugins: Boundary.Input.Plugins,
-  parsers: Boundary.Input.Parsers,
-  files: Boundary.Input.Files,
-  rules: Boundary.Input.Rules,
-): Boundary.Output[] {
-  try {
-    const F = new Files(files),
-    R = new Rulesets(rules),
-    Pa: { [S in Scope]: ConstructorParameters<typeof Options[S]>[3] } = {
-      js: [] as const,
-      ts: [parsers.ts] as const,
-      svelte: [parsers.svelte, parsers.ts] as const,
-      mocha: [parsers.ts] as const,
-      html: [parsers.html] as const,
-      json: [parsers.jsonc] as const,
-      jsonc: [parsers.jsonc] as const,
-      yml: [parsers.yml] as const,
-      md: [parsers.md] as const,
-    } as const,
-    options: { [S in Scope]: InstanceType<typeof Options[S]>["configs"] } = {
-      js: new Options
-        .js(
-          F.files("js"),
-          R.ruleset("js"),
-          { "@stylistic": plugins["@stylistic"] },
-          Pa.js,
-        ).configs,
-      ts: new Options
-        .ts(
-          F.files("ts"),
-          R.ruleset("ts"),
-          { "@stylistic": plugins["@stylistic"], "@typescript-eslint": plugins["@typescript-eslint"] },
-          Pa.ts,
-        ).configs,
-      svelte: new Options
-        .svelte(
-          F.files("svelte"),
-          R.ruleset("svelte"),
-          { "@stylistic": plugins["@stylistic"], "@typescript-eslint": plugins["@typescript-eslint"], svelte: plugins.svelte },
-          Pa.svelte,
-        ).configs,
-      mocha: new Options
-        .mocha(
-          F.files("mocha"),
-          R.ruleset("mocha"),
-          { "@stylistic": plugins["@stylistic"], "@typescript-eslint": plugins["@typescript-eslint"], mocha: plugins.mocha },
-          Pa.mocha,
-        ).configs,
-      html: new Options
-        .html(
-          F.files("html"),
-          R.ruleset("html"),
-          { "@html-eslint": plugins["@html-eslint"] },
-          Pa.html,
-        ).configs,
-      json: new Options
-        .json(
-          F.files("json"),
-          R.ruleset("json"),
-          { jsonc: plugins.jsonc },
-          Pa.json,
-        ).configs,
-      jsonc: new Options
-        .jsonc(
-          F.files("jsonc"),
-          R.ruleset("jsonc"),
-          { jsonc: plugins.jsonc },
-          Pa.jsonc,
-        ).configs,
-      yml: new Options
-        .yml(
-          F.files("yml"),
-          R.ruleset("yml"),
-          { yml: plugins.yml },
-          Pa.yml,
-        ).configs,
-      md: new Options
-        .md(
-          F.files("md"),
-          R.ruleset("md"),
-          { markdownlint: plugins.markdownlint },
-          Pa.md,
-        ).configs,
-    };
-
-    return scopes.flatMap(scope => options[scope]);
-  }
-  catch (e) { throw new Error(`linted-core`, { cause: e }); }
-}
+import scopes, { type Scope } from "./scopes/index.js";
+import type * as Boundary from "./boundary/index.js";
+import { Options, Files, Rulesets } from "./factory/index.js";
+
+export type { Boundary };
+export default function (
+  plugins: Boundary.Input.Plugins,
+  parsers: Boundary.Input.Parsers,
+  files: Boundary.Input.Files,
+  rules: Boundary.Input.Rules,
+): Boundary.Output[] {
+  try {
+    const F = new Files(files),
+    R = new Rulesets(rules),
+    Pa: { [S in Scope]: ConstructorParameters<typeof Options[S]>[3] } = {
+      js: [] as const,
+      ts: [parsers.ts] as const,
+      svelte: [parsers.svelte, parsers.ts] as const,
+      mocha: [parsers.ts] as const,
+      html: [parsers.html] as const,
+      json: [parsers.jsonc] as const,
+      jsonc: [parsers.jsonc] as const,
+      yml: [parsers.yml] as const,
+      md: [parsers.md] as const,
+    } as const,
+    options: { [S in Scope]: InstanceType<typeof Options[S]>["configs"] } = {
+      js: new Options
+        .js(
+          F.files("js"),
+          R.ruleset("js"),
+          { "@stylistic": plugins["@stylistic"] },
+          Pa.js,
+        ).configs,
+      ts: new Options
+        .ts(
+          F.files("ts"),
+          R.ruleset("ts"),
+          { "@stylistic": plugins["@stylistic"], "@typescript-eslint": plugins["@typescript-eslint"] },
+          Pa.ts,
+        ).configs,
+      svelte: new Options
+        .svelte(
+          F.files("svelte"),
+          R.ruleset("svelte"),
+          { "@stylistic": plugins["@stylistic"], "@typescript-eslint": plugins["@typescript-eslint"], svelte: plugins.svelte },
+          Pa.svelte,
+        ).configs,
+      mocha: new Options
+        .mocha(
+          F.files("mocha"),
+          R.ruleset("mocha"),
+          { "@stylistic": plugins["@stylistic"], "@typescript-eslint": plugins["@typescript-eslint"], mocha: plugins.mocha },
+          Pa.mocha,
+        ).configs,
+      html: new Options
+        .html(
+          F.files("html"),
+          R.ruleset("html"),
+          { "@html-eslint": plugins["@html-eslint"] },
+          Pa.html,
+        ).configs,
+      json: new Options
+        .json(
+          F.files("json"),
+          R.ruleset("json"),
+          { jsonc: plugins.jsonc },
+          Pa.json,
+        ).configs,
+      jsonc: new Options
+        .jsonc(
+          F.files("jsonc"),
+          R.ruleset("jsonc"),
+          { jsonc: plugins.jsonc },
+          Pa.jsonc,
+        ).configs,
+      yml: new Options
+        .yml(
+          F.files("yml"),
+          R.ruleset("yml"),
+          { yml: plugins.yml },
+          Pa.yml,
+        ).configs,
+      md: new Options
+        .md(
+          F.files("md"),
+          R.ruleset("md"),
+          { markdownlint: plugins.markdownlint },
+          Pa.md,
+        ).configs,
+    };
+
+    return scopes.flatMap(scope => options[scope]);
+  }
+  catch (e) { throw new Error(`linted-core`, { cause: e }); }
+}

package/src/scopes/index.ts

@@ -1,14 +1,14 @@
-const scopes = [
-  "js",
-  "ts",
-  "svelte",
-  "mocha",
-  "html",
-  "json",
-  "jsonc",
-  "yml",
-  "md",
-] as const;
-
-export default scopes;
-export type Scope = (typeof scopes)[number];
+const scopes = [
+  "js",
+  "ts",
+  "svelte",
+  "mocha",
+  "html",
+  "json",
+  "jsonc",
+  "yml",
+  "md",
+] as const;
+
+export default scopes;
+export type Scope = (typeof scopes)[number];