@eslinted/core 4.0.5-rc.4 → 4.0.5-rc.6

package/package.json

@@ -1,7 +1,7 @@
 {
   "_schemaVersion": "20.18.0-core.0",
   "name": "@eslinted/core",
-  "version": "4.0.5-rc.4",
+  "version": "4.0.5-rc.6",
   "description": "Core ESLint flat config factory npm package `linted`.",
   "keywords": [],
   "repository": "github:jimmy-zhening-luo/linted-core",
@@ -13,14 +13,8 @@
     "access": "public"
   },
   "type": "module",
-  "exports": {
-    ".": {
-      "import": {
-        "types": "./dist/index.d.ts",
-        "default": "./dist/index.js"
-      }
-    }
-  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
   "config": {
     "language": "ts",
     "fix": "true",

package/src/factory/files.ts

@@ -1,15 +1,26 @@
-import type { Scope } from "@eslinted/core";
-import type { Input } from "@eslinted/core";
+import type { Input } from ".";
 
 export class Files {
-  constructor(private readonly input: Input["files"]) {}
+  private readonly _files = new Map<string, string[]>();
 
-  public files(scope: Scope): readonly string[] {
-    try {
-      const { files, includes } = this.input;
+  constructor(private readonly input: Input["files"]) {
+    const { files, includes } = this.input,
+    scopes = Object.keys(files) as (keyof typeof files)[];
 
-      return [...files[scope], ...includes[scope] ?? []];
-    }
-    catch (e) { throw new Error(`linted.factory.Files/scope:${scope}`, { cause: e }); }
+    for (const scope of scopes)
+      this._files.set(
+        scope,
+        [
+          ...files[scope],
+          ...scope in includes ? (includes[scope] as string[]) : [],
+        ],
+      );
+  }
+
+  public files(scope: string) {
+    if (!this._files.has(scope))
+      throw new ReferenceError(`Files not found for scope: ${scope}`);
+
+    return this._files.get(scope) as string[];
   }
 }

package/src/factory/index.ts

@@ -1,5 +1,7 @@
-import { Rulesets } from "./rulesets";
-import { Files } from "./files";
+export type { Scope, Input, Output } from "..";
+
 import Options from "./options";
+import { Files } from "./files";
+import { Rulesets } from "./rulesets";
 
 export { Options, Files, Rulesets };

package/src/factory/options/index.ts

@@ -1,3 +1,5 @@
+export type { Scope, Input, Output } from "..";
+
 import js from "./js";
 import ts from "./ts";
 import svelte from "./svelte";

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

@@ -1,14 +1,14 @@
-import type { Input } from "@eslinted/core";
-import type { Scope } from "@eslinted/core";
-import type { Output } from "@eslinted/core";
-import type { Ruleset } from "../../ruleset";
+import globals from "globals";
+import type { Ruleset } from "../../rulesets/ruleset";
 import type {
+  Scope,
+  Input,
+  Output,
   OptionTemplate,
   LanguageOptions,
   Plugins,
   Globals,
 } from "./template";
-import globals from "globals";
 
 export default abstract class Option<
   S extends Scope,
@@ -29,41 +29,33 @@ export default abstract class Option<
       : object;
 
   constructor(
-    public readonly files: readonly string[],
-    public readonly ruleset: Ruleset<S>,
     public readonly plugins: Plugins<Plugin>,
     public readonly parser: Tuple<unknown, ParserCount>,
+    public readonly files: string[],
+    public readonly ruleset: Ruleset,
   ) {}
 
   public get configs(): Output {
-    try {
-      const {
-        scope,
-        ruleset,
-        files,
-        option,
-      } = this;
-
-      if (ruleset.id !== scope)
-        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;
+    const {
+      scope,
+      ruleset,
+      files,
+      option,
+    } = this;
 
-        return ruleset.records.map(([ruleId, rules]) => {
-          const name = `${baseName}+${ruleId}` as const;
+    if (ruleset.scope !== scope)
+      throw new TypeError(`Scope mismatch between option and ruleset`, { cause: { option: scope, ruleset: ruleset.scope } });
 
-          return {
-            name,
-            files,
-            rules,
-            ...option,
-          };
-        });
-      }
-    }
-    catch (e) { throw new Error(`linted.factory.Option/scope:${this.scope}: configs`, { cause: e }); }
+    return files.length < 1
+      ? []
+      : ruleset.ruleset.map(({ id, rule }) => {
+        return {
+          name: `linted/${id}`,
+          files,
+          rules: rule,
+          ...option,
+        };
+      });
   }
 
   private get option() {

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

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

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

@@ -1,7 +1,9 @@
-import type { LanguageOptions } from "./params/language";
-import type { Linter } from "./params/linter";
-import type { Plugins } from "./params/plugins";
-import type { Globals } from "./params/globals";
+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,

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

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

package/src/factory/options/option/{params/language.ts → template/language/index.ts}

@@ -1,12 +1,12 @@
-import type { Ecma } from "./languageOptions/ecma";
-import type { Source } from "./languageOptions/source";
+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: Ecma; sourceType: Source })
+ & (True<IsEcma> extends never ? object : { ecmaVersion: EcmaVersion; sourceType: SourceType })
  & (literalful<GlobalTypes> extends never ? object : { globals: Record<string, unknown> })
  & (
     ParserOptions extends boolean

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

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

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

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

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

@@ -0,0 +1 @@
+export type Plugins<PluginId extends string> = { [P in literalful<PluginId>]: { configs: unknown } };

package/src/factory/rulesets/index.ts

@@ -0,0 +1,24 @@
+import type { Input } from "..";
+
+export type { Input };
+
+import { Ruleset } from "./ruleset";
+
+export class Rulesets {
+  private readonly rulesets = new Map<string, Ruleset>();
+
+  constructor(private readonly input: Input["rules"]) {
+    const { rules, overrides } = this.input,
+    scopes = Object.keys(rules) as (keyof typeof rules)[];
+
+    for (const scope of scopes)
+      this.rulesets.set(scope, new Ruleset(scope, rules[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

@@ -0,0 +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])],
+    ];
+  }
+}

package/src/index.ts

@@ -1,8 +1,9 @@
+export type { Scope } from "./scopes";
+
 import type { Input } from "./input";
-import type { Scope } from "./scopes";
 import type { Output } from "./output";
 
-export type { Input, Scope, Output };
+export type { Input, Output };
 
 import { scopes } from "./scopes";
 import {
@@ -23,66 +24,66 @@ export default function (
     options: { [S in typeof scopes[number]]: InstanceType<typeof Options[S]>["configs"] } = {
       js: new Options
         .js(
-          F.files("js"),
-          R.ruleset("js"),
           { "@stylistic": plugins["@stylistic"] },
           [],
+          F.files("js"),
+          R.ruleset("js"),
         ).configs,
       ts: new Options
         .ts(
-          F.files("ts"),
-          R.ruleset("ts"),
           { "@stylistic": plugins["@stylistic"], "@typescript-eslint": plugins["@typescript-eslint"] },
           [parsers.ts],
+          F.files("ts"),
+          R.ruleset("ts"),
         ).configs,
       svelte: new Options
         .svelte(
-          F.files("svelte"),
-          R.ruleset("svelte"),
           { "@stylistic": plugins["@stylistic"], "@typescript-eslint": plugins["@typescript-eslint"], svelte: plugins.svelte },
           [parsers.svelte, parsers.ts],
+          F.files("svelte"),
+          R.ruleset("svelte"),
         ).configs,
       mocha: new Options
         .mocha(
-          F.files("mocha"),
-          R.ruleset("mocha"),
           { "@stylistic": plugins["@stylistic"], "@typescript-eslint": plugins["@typescript-eslint"], mocha: plugins.mocha },
           [parsers.ts],
+          F.files("mocha"),
+          R.ruleset("mocha"),
         ).configs,
       html: new Options
         .html(
-          F.files("html"),
-          R.ruleset("html"),
           { "@html-eslint": plugins["@html-eslint"] },
           [parsers.html],
+          F.files("html"),
+          R.ruleset("html"),
         ).configs,
       json: new Options
         .json(
-          F.files("json"),
-          R.ruleset("json"),
           { jsonc: plugins.jsonc },
           [parsers.jsonc],
+          F.files("json"),
+          R.ruleset("json"),
         ).configs,
       jsonc: new Options
         .jsonc(
-          F.files("jsonc"),
-          R.ruleset("jsonc"),
           { jsonc: plugins.jsonc },
           [parsers.jsonc],
+          F.files("jsonc"),
+          R.ruleset("jsonc"),
         ).configs,
       yml: new Options
         .yml(
-          F.files("yml"),
-          R.ruleset("yml"),
           { yml: plugins.yml },
           [parsers.yml],
+          F.files("yml"),
+          R.ruleset("yml"),
         ).configs,
       md: new Options
         .md(
-          F.files("md"),
-          R.ruleset("md"),
           { markdownlint: plugins.markdownlint },
           [parsers.md],
+          F.files("md"),
+          R.ruleset("md"),
         ).configs,
     };
 
@@ -91,8 +92,9 @@ export default function (
   catch (e) { throw new Error(`linted-core`, { cause: e }); }
 }
 
+// #region DEPRECATED
 namespace Core {
-  export type Scopes = Scope;
+  export type Scopes = typeof scopes[number];
   export namespace Input {
     export type Parsers = Input["parsers"];
     export type Plugins = Input["plugins"];
@@ -111,3 +113,5 @@ namespace Core {
 }
 
 export type { Core };
+
+// #endregion

package/src/input/files.ts

@@ -0,0 +1,6 @@
+import type { Scope } from ".";
+
+export interface FilesInput {
+  files: Record<Scope, string[]>;
+  includes: Partial<FilesInput["files"]>;
+}

package/src/{inputs → input}/imports/parsers.ts

@@ -1,4 +1,4 @@
-import type { Scope } from "@eslinted/core";
+import type { Scope } from "..";
 
 export type Parsers = Scope
   & (

package/src/{inputs → input}/imports/plugins.ts

@@ -1,4 +1,4 @@
-export type Plugins =
+export type Plugins = (
   | "@stylistic"
   | "@typescript-eslint"
   | "svelte"
@@ -6,4 +6,5 @@ export type Plugins =
   | "@html-eslint"
   | "jsonc"
   | "yml"
-  | "markdownlint";
+  | "markdownlint"
+);

package/src/input/index.ts

@@ -0,0 +1,23 @@
+export type { Scope } from "../scopes";
+
+import type { PluginsInput } from "./plugins";
+import type { ParsersInput } from "./parsers";
+import type { FilesInput } from "./files";
+import type { RulesInput } from "./rules";
+
+export interface Input {
+  plugins: PluginsInput;
+  parsers: ParsersInput;
+  files: FilesInput;
+  rules: RulesInput;
+}
+export namespace Input {
+  export type Rule = RulesInput;
+  export namespace Rule {
+    export type Entry = RulesInput.Entry;
+    export namespace Entry {
+      export type Id = RulesInput.Entry.Id;
+      export type Record = RulesInput.Entry.Record;
+    }
+  }
+}

package/src/input/parsers.ts

@@ -0,0 +1,3 @@
+import type { Parsers } from "./imports/parsers";
+
+export type ParsersInput = Record<Parsers, unknown>;

package/src/input/plugins.ts

@@ -0,0 +1,3 @@
+import type { Plugins } from "./imports/plugins";
+
+export type PluginsInput = Record<Plugins, { configs: unknown }>;

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

@@ -0,0 +1,7 @@
+import type { RuleRecord } from "./record";
+
+export type RuleEntry = readonly [string, RuleRecord];
+export namespace RuleEntry {
+  export type Id = string;
+  export type Record = RuleRecord;
+}

package/src/input/rules/entry/record/index.ts

@@ -0,0 +1,3 @@
+import type { RuleState } from "./state";
+
+export type RuleRecord = Table<RuleState | readonly [RuleState, ...unknown[]]>;

package/src/input/rules/entry/record/state.ts

@@ -0,0 +1,5 @@
+export type RuleState = (
+  | "error"
+  | "warn"
+  | "off"
+);

package/src/input/rules/index.ts

@@ -0,0 +1,14 @@
+import type { Scope } from "..";
+import type { RuleEntry } from "./entry";
+
+export interface RulesInput {
+  rules: Record<Scope, RuleEntry[]>;
+  overrides: Partial<Record<Scope, RuleEntry.Record>>;
+}
+export namespace RulesInput {
+  export type Entry = RuleEntry;
+  export namespace Entry {
+    export type Id = RuleEntry.Id;
+    export type Record = RuleEntry.Record;
+  }
+}

package/src/output.ts

@@ -1,24 +1,24 @@
-import type { Input } from "./input";
+import type { Input } from ".";
 
-interface Config {
-  name: `linted/scope:${string}/rule:${string}+${string}`;
-  rules: Input["rules"]["rules"]["html"][number][1];
-  files: readonly string[];
-  linterOptions: {
-    noInlineConfig: true;
-    reportUnusedDisableDirectives: "error";
-  };
-  languageOptions: {
-    sourceType?:
-      | "module"
-      | "script";
-    ecmaVersion?: "latest";
-    globals?: Record<string, true>;
-    parser?: unknown;
-    parserOptions?: Record<string, unknown>;
-  };
-  plugins: Record<string, Record<"configs", unknown>>;
-  processor?: string;
-}
-
-export type Output = Config[];
+export type Output = (
+  {
+    name: `linted/${string}`;
+    rules: Input["rules"]["rules"]["html"][number][1];
+    files: string[];
+    linterOptions: {
+      noInlineConfig: true;
+      reportUnusedDisableDirectives: "error";
+    };
+    languageOptions: {
+      sourceType?:
+        | "module"
+        | "script";
+      ecmaVersion?: "latest";
+      globals?: Table<true>;
+      parser?: unknown;
+      parserOptions?: Record<string, unknown>; // TODO: Change to Table<unknown> after lib update
+    };
+    plugins: Table<Record<"configs", unknown>>;
+    processor?: string;
+  }
+)[];

package/src/scopes.ts

@@ -1,3 +1,4 @@
+export type Scope = typeof scopes[number];
 export const scopes = [
   "js",
   "ts",
@@ -9,4 +10,3 @@ export const scopes = [
   "yml",
   "md",
 ] as const;
-export type Scope = (typeof scopes)[number];

package/tsconfig.json

@@ -1,7 +1,7 @@
 {
   "display": "@jimbojet/tsc",
   "$schema": "https://json.schemastore.org/tsconfig",
-  "_version": "5.6.1",
+  "_version": "5.6.1-core.1",
   "include": [
     "*.config.ts",
     "src/**/*.ts",
@@ -10,7 +10,7 @@
   ],
   "exclude": [],
   "compilerOptions": {
-    /* http://aka.ms/tsconfig#quick-nav-Top%20Level */
+    /* https://www.typescriptlang.org/tsconfig/#quick-nav-Top%20Level */
 
     // #region TYPE CHECKING
     "allowUnreachableCode": false,

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

@@ -1,3 +0,0 @@
-import type globals from "globals";
-
-export type Globals = keyof typeof globals & "mocha";

package/src/factory/options/option/params/languageOptions/ecma.ts

@@ -1 +0,0 @@
-export type Ecma = "latest";

package/src/factory/options/option/params/languageOptions/source.ts

@@ -1 +0,0 @@
-export type Source = "module" | "script";

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

@@ -1,4 +0,0 @@
-export interface Linter {
-  noInlineConfig: true;
-  reportUnusedDisableDirectives: "error";
-}

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

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

package/src/factory/ruleset/index.ts

@@ -1,41 +0,0 @@
-import type { Input } from "@eslinted/core";
-import type { Scope } from "@eslinted/core";
-import { Rule } from "./rule";
-
-export { Rule };
-export 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 | Input["rules"]["rules"][Scope][number][1]) {
-    if (typeof overrides !== "undefined")
-      this.overrides = new Rule("override", overrides);
-
-    return this;
-  }
-}

package/src/factory/ruleset/rule.ts

@@ -1,8 +0,0 @@
-import type { Input } from "@eslinted/core";
-
-export class Rule {
-  constructor(
-    public readonly id: string,
-    public readonly rules: Input["rules"]["rules"]["html"][number][1],
-  ) {}
-}

package/src/factory/rulesets.ts

@@ -1,16 +0,0 @@
-import type { Input } from "@eslinted/core";
-import type { Scope } from "@eslinted/core";
-import { Ruleset, Rule } from "./ruleset";
-
-export class Rulesets {
-  constructor(private readonly input: Input["rules"]) {}
-
-  public ruleset<S extends Scope>(scope: literalful<S>): Ruleset<S> {
-    try {
-      const { rules, overrides } = this.input;
-
-      return new Ruleset<S>(scope, ...rules[scope].map(args => new Rule(...args))).override(overrides[scope]);
-    }
-    catch (e) { throw new Error(`linted.factory.Rulesets/ruleset/scope:${scope}`, { cause: e }); }
-  }
-}

package/src/input.ts

@@ -1,11 +0,0 @@
-import type { Plugins } from "./inputs/plugins";
-import type { Parsers } from "./inputs/parsers";
-import type { Files } from "./inputs/files";
-import type { Rules } from "./inputs/rules";
-
-export interface Input {
-  files: Files;
-  rules: Rules;
-  plugins: Plugins;
-  parsers: Parsers;
-}

package/src/inputs/files/base.ts

@@ -1,3 +0,0 @@
-import type { Scope } from "@eslinted/core";
-
-export type Base = Readonly<Record<Scope, readonly string[]>>;

package/src/inputs/files/includes.ts

@@ -1,3 +0,0 @@
-import type { Base } from "./base";
-
-export type Includes = Partial<Base>;

package/src/inputs/files.ts

@@ -1,7 +0,0 @@
-import type { Base } from "./files/base";
-import type { Includes } from "./files/includes";
-
-export interface Files {
-  files: Base;
-  includes: Includes;
-}

package/src/inputs/imports.ts

@@ -1,2 +0,0 @@
-export type { Plugins } from "./imports/plugins";
-export type { Parsers } from "./imports/parsers";

package/src/inputs/parsers.ts

@@ -1,3 +0,0 @@
-import type { Parsers as Imports } from "./imports/parsers";
-
-export type Parsers = Readonly<Record<Imports, unknown>>;

package/src/inputs/plugins.ts

@@ -1,3 +0,0 @@
-import type { Plugins as Imports } from "./imports/plugins";
-
-export type Plugins = Readonly<Record<Imports, { configs: unknown }>>;

package/src/inputs/rules/entry/index.ts

@@ -1,3 +0,0 @@
-import type { RuleRecord } from "./object";
-
-export type RuleEntry = readonly [string, RuleRecord];

package/src/inputs/rules/entry/object/index.ts

@@ -1,7 +0,0 @@
-import type { State } from "./state";
-
-export type RuleRecord = Readonly<Record<
-  string,
-  | State
-  | readonly [State, ...unknown[]]
->>;

package/src/inputs/rules/entry/object/state/index.ts

@@ -1,4 +0,0 @@
-export type State =
-  | "error"
-  | "warn"
-  | "off";

package/src/inputs/rules/overrides.ts

@@ -1,4 +0,0 @@
-import type { Scope } from "@eslinted/core";
-import type { Preset } from "./preset";
-
-export type Overrides = Readonly<Partial<Record<Scope, Preset[Scope][number][1]>>>;

package/src/inputs/rules/preset.ts

@@ -1,4 +0,0 @@
-import type { Scope } from "@eslinted/core";
-import type { RuleEntry } from "./entry";
-
-export type Preset = Readonly<Record<Scope, readonly RuleEntry[]>>;

package/src/inputs/rules.ts

@@ -1,7 +0,0 @@
-import type { Preset } from "./rules/preset";
-import type { Overrides } from "./rules/overrides";
-
-export interface Rules {
-  rules: Preset;
-  overrides: Overrides;
-}