@eslinted/core 18.9.0-rc.1 → 18.9.0

package/src/factory/scopes/manifest/index.ts

@@ -1,16 +1,32 @@
-import type globals from "globals";
 import type { Imports } from "../../../scopes";
 
-export abstract class ScopeManifest<Parser extends Imports.Parser | false = false> {
-  public abstract readonly processor: { readonly processor: string } | Record<string, never>;
-  public abstract readonly language: { readonly language: string } | Record<string, never>;
-  public abstract readonly parserOptions: object & { readonly parser: null | Exclude<Parser, boolean> };
-  public abstract readonly languageOptions: (
-    [Parser] extends [boolean]
-      ? { readonly parser: null }
-      : { readonly parser: Parser }
-
-  ) & (
-    { readonly globals: null | keyof typeof globals }
-  );
+export abstract class ScopeManifest {
+  public abstract processor:
+    | {
+      processor: string;
+    }
+    | Record<string, never>
+  ;
+  public abstract language:
+    | {
+      language: string;
+    }
+    | Record<string, never>
+  ;
+  public abstract parserOptions: {
+    parser:
+      | null
+      | Imports.Parsers
+    ;
+  };
+  public abstract languageOptions: {
+    parser:
+      | null
+      | Imports.Parsers
+    ;
+    globals:
+      | null
+      | string
+    ;
+  };
 }

package/src/factory/scopes/mocha.ts

@@ -1,11 +1,11 @@
 import { ScopeManifest } from "./manifest";
 
 export default class MochaManifest extends ScopeManifest {
-  public readonly languageOptions = {
+  public languageOptions = {
     parser: null,
-    globals: "mocha",
-  } as const;
-  public readonly parserOptions = {
+    globals: "mocha" as const,
+  };
+  public parserOptions = {
     // MUST BE IDENTICAL TO TS PARSER OPTIONS (eventually see if can inherit)
     parser: null,
     ecmaFeatures: {
@@ -18,7 +18,7 @@ export default class MochaManifest extends ScopeManifest {
     warnOnUnsupportedTypeScriptVersion: false,
     sourceType: "module",
     ecmaVersion: 2023,
-  } as const;
-  public readonly processor = {} as const;
-  public readonly language = {} as const;
+  };
+  public processor = {};
+  public language = {};
 }

package/src/factory/scopes/svelte.ts

@@ -1,13 +1,13 @@
 import { ScopeManifest } from "./manifest";
 
-export default class SvelteManifest extends ScopeManifest<"svelte" | "ts"> {
-  public readonly languageOptions = {
-    parser: "svelte",
+export default class SvelteManifest extends ScopeManifest {
+  public languageOptions = {
+    parser: "svelte" as const,
     globals: null,
-  } as const;
-  public readonly parserOptions = {
-    parser: "ts",
-    extraFileExtensions: [".svelte"] as const,
+  };
+  public parserOptions = {
+    parser: "ts" as const,
+    extraFileExtensions: [".svelte"],
     ecmaFeatures: {
       jsx: false,
       globalReturn: true,
@@ -18,7 +18,9 @@ export default class SvelteManifest extends ScopeManifest<"svelte" | "ts"> {
     warnOnUnsupportedTypeScriptVersion: false,
     sourceType: "module",
     ecmaVersion: 2023,
-  } as const;
-  public readonly processor = { processor: "svelte/svelte" } as const;
-  public readonly language = {} as const;
+  };
+  public processor = {
+    processor: "svelte/svelte",
+  };
+  public language = {};
 }

package/src/factory/scopes/ts.ts

@@ -1,11 +1,11 @@
 import { ScopeManifest } from "./manifest";
 
-export default class TsManifest extends ScopeManifest<"ts"> {
-  public readonly languageOptions = {
-    parser: "ts",
+export default class TsManifest extends ScopeManifest {
+  public languageOptions = {
+    parser: "ts" as const,
     globals: null,
-  } as const;
-  public readonly parserOptions = {
+  };
+  public parserOptions = {
     // DOC: https://typescript-eslint.io/packages/parser/#configuration
     // DOC:(USE-CASE): https://typescript-eslint.io/getting-started/typed-linting/
     parser: null,
@@ -19,7 +19,7 @@ export default class TsManifest extends ScopeManifest<"ts"> {
     warnOnUnsupportedTypeScriptVersion: false,
     sourceType: "module",
     ecmaVersion: 2023,
-  } as const;
-  public readonly processor = {} as const;
-  public readonly language = {} as const;
+  };
+  public processor = {};
+  public language = {};
 }

package/src/factory/scopes/yml.ts

@@ -1,15 +1,15 @@
 import { ScopeManifest } from "./manifest";
 
-export default class YmlManifest extends ScopeManifest<"yml"> {
-  public readonly languageOptions = {
-    parser: "yml",
+export default class YmlManifest extends ScopeManifest {
+  public languageOptions = {
+    parser: "yml" as const,
     globals: null,
-  } as const;
-  public readonly parserOptions = {
+  };
+  public parserOptions = {
     /* DOC: https://github.com/ota-meshi/yaml-eslint-parser?tab=readme-ov-file#advanced-configuration */
     parser: null,
     defaultYAMLVersion: "1.2" /* @default: "1.2" | "1.1" */,
-  } as const;
-  public readonly processor = {} as const;
-  public readonly language = {} as const;
+  };
+  public processor = {};
+  public language = {};
 }

package/src/index.spec.ts

@@ -24,7 +24,7 @@ describe("Core", function () {
     });
     it("containing only config-like members", function () {
       expect(configs)
-        .satisfies((configs: readonly unknown[]) => configs.every(config => typeof config === "object" && config !== null && "name" in config && typeof config.name === "string"));
+        .satisfies((configs: unknown[]) => configs.every(config => typeof config === "object" && config !== null && "name" in config && typeof config.name === "string"));
     });
   });
   describe("configs", function () {

package/src/interface/input/imported.ts

@@ -4,9 +4,9 @@ export interface Imported<
   Plugins extends string,
   Parsers extends string,
 > {
-  readonly plugins: Config.Config<Plugins>["plugins"];
-  readonly parsers: Readonly<Record<
+  plugins: Config.Config<Plugins>["plugins"];
+  parsers: Record<
     Parsers,
     unknown
-  >>;
+  >;
 }

package/src/interface/input/index.ts

@@ -3,10 +3,10 @@ import type { Imported } from "./imported";
 import type { Defaults, Extensions } from "./scopes";
 
 export interface Input {
-  readonly imports: Imported<
-    Imports.Plugin,
-    Imports.Parser
+  imports: Imported<
+    Imports.Plugins,
+    Imports.Parsers
   >;
-  readonly defaults: Defaults<Scope>;
-  readonly extensions: Extensions<Scope>;
+  defaults: Defaults<Scope>;
+  extensions: Extensions<Scope>;
 }

package/src/interface/input/scopes/defaults.ts

@@ -1,8 +1,8 @@
 import type { Config } from "../../proto";
 
 export interface Defaults<Scopes extends string> {
-  readonly settings: Config.Config["linterOptions"] & Config.Config["languageOptions"];
-  readonly files: Readonly<Record<Scopes, string[]>>;
-  readonly ignores: Readonly<Record<"*" | Scopes, string[]>>;
-  readonly rules: Readonly<Record<Scopes, Config.Rule.NamedRuleBag[]>>;
+  settings: Config.Config["linterOptions"] & Config.Config["languageOptions"];
+  files: Record<Scopes, string[]>;
+  ignores: Record<"*" | Scopes, string[]>;
+  rules: Record<Scopes, Config.Rule.NamedRuleBag[]>;
 }

package/src/interface/input/scopes/extensions.ts

@@ -2,17 +2,17 @@ import type { Defaults } from "./defaults";
 
 export type Extensions<Scopes extends string> = (
   & {
-    readonly "*"?: Partial<Defaults<Scopes>["settings"]> & {
-      readonly override?: boolean;
-      readonly ignores?: Defaults<Scopes>["ignores"]["*"];
+    "*"?: Partial<Defaults<Scopes>["settings"]> & {
+      override?: boolean;
+      ignores?: Defaults<Scopes>["ignores"]["*"];
     };
   }
   & Partial<Record<
     Scopes,
     {
-      readonly files?: Defaults<Scopes>["files"][Scopes];
-      readonly ignores?: Defaults<Scopes>["ignores"][Scopes];
-      readonly rules?: Defaults<Scopes>["rules"][Scopes][number]["rules"];
+      files?: Defaults<Scopes>["files"][Scopes];
+      ignores?: Defaults<Scopes>["ignores"][Scopes];
+      rules?: Defaults<Scopes>["rules"][Scopes][number]["rules"];
     }
   >>
 );

package/src/interface/output/configs/scoped/rules.ts

@@ -1,7 +1,7 @@
 import type { Config } from "../../../proto";
 
-export type Rules<Scope extends string> = Config.PickConfig<
-  `linted/${Scope}/${string}/`,
+export type Rules = Config.PickConfig<
+  `linted/${string}`,
   | "files"
   | "ignores"
   | "rules"

package/src/interface/output/configs/scoped/settings.ts

@@ -1,12 +1,14 @@
 import type { Config } from "../../../proto";
 
-export type Settings<Scope extends string> = Config.PickConfig<
-  `linted/${Scope}/`,
+export type Settings = Config.PickConfig<
+  `linted/${string}`,
   | "files"
   | "ignores"
   | "processor"
   | "language"
   | "settings",
   string,
-  { readonly languageOptions: object }
+  {
+    languageOptions: object;
+  }
 >;

package/src/interface/output/index.ts

@@ -1,9 +1,9 @@
 import type * as Configs from "./configs";
-import type { Imports, Scope } from "../../scopes";
+import type { Imports } from "../../scopes";
 
 export type Output = readonly [
-  Configs.Global.Plugins<Imports.Plugin>,
+  Configs.Global.Plugins<Imports.Plugins>,
   Configs.Global.Settings,
   Configs.Global.Ignores,
-  ...readonly (Configs.Scoped.Settings<Scope> | Configs.Scoped.Rules<Scope>)[],
+  ...(Configs.Scoped.Settings | Configs.Scoped.Rules)[],
 ];

package/src/interface/proto/config/index.ts

@@ -3,25 +3,25 @@ import type * as Rule from "./rule";
 export type { Rule };
 export type * from "./utility";
 export interface Config<Plugins extends string = string> {
-  readonly name: `linted/${string}/`;
-  readonly plugins: Readonly<Record<Plugins, unknown>>;
-  readonly files: readonly string[];
-  readonly ignores: readonly string[];
-  readonly rules: Rule.RuleBag;
-  readonly linterOptions: {
-    readonly noInlineConfig: boolean;
-    readonly reportUnusedDisableDirectives:
+  name: `linted/${string}`;
+  plugins: Record<Plugins, unknown>;
+  files: string[];
+  ignores: string[];
+  rules: Rule.RuleBag;
+  linterOptions: {
+    noInlineConfig: boolean;
+    reportUnusedDisableDirectives:
       | "error"
       | "warn"
       | "off"
     ;
   };
-  readonly languageOptions: {
-    readonly sourceType:
+  languageOptions: {
+    sourceType:
       | "module"
       | "script"
     ;
-    readonly ecmaVersion:
+    ecmaVersion:
       | "latest"
       | 3
       | 5
@@ -37,7 +37,7 @@ export interface Config<Plugins extends string = string> {
       | 2024
     ;
   };
-  readonly processor?: string;
-  readonly language?: string;
-  readonly settings?: Readonly<Record<string, unknown>>;
+  processor?: string;
+  language?: string;
+  settings?: Record<string, unknown>;
 }

package/src/interface/proto/config/rule/index.ts

@@ -1,12 +1,12 @@
 export interface NamedRuleBag {
   id: string;
-  readonly rules: RuleBag;
+  rules: RuleBag;
 }
-export type RuleBag = Readonly<Record<
+export type RuleBag = Record<
   string,
   | RuleState
-  | readonly [RuleState, ...readonly unknown[]]
->>;
+  | readonly [RuleState, ...unknown[]]
+>;
 export type RuleState = (
   | "error"
   | "warn"

package/src/interface/proto/config/utility/index.ts

@@ -12,8 +12,8 @@ export type PickConfig<
 > = (
   & Rest
   & Pick<Config<Plugins>, Picks>
-  & { readonly name: Name }
-  & Readonly<Partial<Record<
+  & { name: Name }
+  & Partial<Record<
     Exclude<
       keyof Config,
       | "name"
@@ -21,5 +21,5 @@ export type PickConfig<
       | Picks
     >,
     never
-  >>>
+  >>
 );

package/src/scopes/imports/index.ts

@@ -1,5 +1,5 @@
 export namespace Imports {
-  export type Plugin = (
+  export type Plugins = (
     | "@stylistic"
     | "@typescript-eslint"
     | "mocha"
@@ -12,7 +12,7 @@ export namespace Imports {
     | "jsonc"
     | "yml"
   );
-  export type Parser = (
+  export type Parsers = (
     | "ts"
     | "svelte"
     | "html"

package/src/scopes/tree/index.ts

@@ -1,8 +1,8 @@
 import type { Scope } from "..";
 
-export const tree: [Scope, readonly Scope[]][] = [
-  ["jsonc", ["json"] as const] as const,
-  ["mocha", ["ts"] as const] as const,
-  ["svelte", ["ts"] as const] as const,
-  ["ts", ["js"] as const] as const,
-] as const;
+export const tree: [Scope, Scope[]][] = [
+  ["jsonc", ["json"]] as const,
+  ["mocha", ["ts"]] as const,
+  ["svelte", ["ts"]] as const,
+  ["ts", ["js"]] as const,
+];