@eslinted/core 0.0.1-rc.0 → 0.0.1-rc.3

package/interface/option/language/ecma/IOLanguageEcma.d.ts

@@ -0,0 +1,20 @@
+declare type IOLanguageEcma<Ecma extends number | IOLanguageEcma.Ecma> = [Ecma] extends [number]
+  ? Numbered<Ecma> extends never
+    ? object
+    : { ecmaVersion: Numbered<Ecma> }
+
+  : [Ecma] extends [string]
+      ? literalful<Ecma> extends never
+        ? object
+        : literalful<Ecma> extends IOLanguageEcma.Ecma
+          ? { ecmaVersion: literalful<Ecma> }
+          : object
+      : object;
+
+declare namespace IOLanguageEcma {
+  export type Ecma =
+    | `${number}`
+    | `ES${number}`
+    | `es${number}`
+    | "latest";
+}

package/interface/option/language/globals/IOLanguageGlobals.d.ts

@@ -0,0 +1,3 @@
+declare type IOLanguageGlobals<GlobalTypes extends string> = literalful<GlobalTypes> extends never
+  ? object
+  : { globals: Record<literalful<GlobalTypes>, true> };

package/interface/option/language/parser/IOLanguageParser.d.ts

@@ -0,0 +1,3 @@
+declare type IOLanguageParser<UseParser extends boolean> = True<UseParser> extends never
+  ? object
+  : { parser: unknown };

package/interface/option/language/parserOptions/IOLanguageParserOptions.d.ts

@@ -0,0 +1,5 @@
+declare type IOLanguageParserOptions<ParserOptions extends object> = Interface<ParserOptions> extends never
+  ? object
+  : Keys<ParserOptions> extends never
+    ? object
+    : { parserOptions: Interface<ParserOptions> };

package/interface/option/language/source/IOLanguageSource.d.ts

@@ -0,0 +1,12 @@
+declare type IOLanguageSource<Source extends IOLanguageSource.Source> = literalful<Source> extends never
+  ? object
+  : literalful<Source> extends IOLanguageSource.Source
+    ? { sourceType: literalful<Source> }
+    : object;
+
+declare namespace IOLanguageSource {
+  export type Source =
+    | "module"
+    | "script"
+    | "commonjs";
+}

package/interface/option/linter/IOLinter.d.ts

@@ -0,0 +1,30 @@
+declare type IOLinter<
+  NoInline extends boolean,
+  ReportUnused extends
+  | boolean
+  | IOLinter.States,
+> = {
+  linterOptions: {
+    noInlineConfig: True<NoInline> extends never
+      ? false
+      : True<NoInline>;
+    reportUnusedDisableDirectives: [ReportUnused] extends [boolean]
+      ? True<ReportUnused> extends never
+        ? false
+        : True<ReportUnused>
+      : [ReportUnused] extends [string]
+          ? literalful<ReportUnused> extends never
+            ? false
+            : literalful<ReportUnused> extends IOLinter.States
+              ? literalful<ReportUnused>
+              : false
+          : false;
+  };
+};
+
+declare namespace IOLinter {
+  export type States =
+    | "error"
+    | "warn"
+    | "off";
+}

package/interface/option/name/IOName.d.ts

@@ -0,0 +1,3 @@
+declare type IOName<Name extends string> = literalful<Name> extends never
+  ? never
+  : { name: literalful<Name> };

package/interface/option/plugins/IOPlugins.d.ts

@@ -0,0 +1,3 @@
+declare type IOPlugins<PluginId extends string> = literalful<PluginId> extends never
+  ? never
+  : { plugins: Record<literalful<PluginId>, { configs: unknown }> };

package/interface/option/processor/IOProcessor.d.ts

@@ -0,0 +1,3 @@
+declare type IOProcessor<ProcessorId extends string> = literalful<ProcessorId> extends never
+  ? object
+  : { processor: literalful<ProcessorId> };

package/interface/rules/IRules.d.ts

@@ -0,0 +1 @@
+declare interface IRules { rules: IRule }

package/interface/rules/rule/IRule.d.ts

@@ -0,0 +1 @@
+type IRule = Record<string, RuleSeverity | [RuleSeverity, ...unknown[]]>;

package/interface/rules/rule/state/RuleSeverity.d.ts

@@ -0,0 +1,5 @@
+declare type RuleSeverity =
+  | "error"
+  | "warn"
+  | "off"
+;

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "@eslinted/core",
-  "version": "0.0.1-rc.0",
+  "version": "0.0.1-rc.3",
   "description": "",
   "keywords": [],
   "license": "MIT",
   "type": "module",
   "private": false,
   "config": {
-    "PACKAGE_JSON_VERSION": "20.9.0"
+    "PACKAGE_JSON_VERSION": "20.9.1"
   },
   "repository": {
     "type": "git",

package/src/Scope.d.ts

@@ -0,0 +1,9 @@
+declare type Scope =
+  | "js"
+  | "ts"
+  | "svelte"
+  | "html"
+  | "json"
+  | "jsonc"
+  | "yml"
+;

package/src/index.ts

@@ -0,0 +1,113 @@
+import scopes from "./scopes.js";
+import options from "./options.js";
+import type Ruleset from "./rulesets/ruleset/Ruleset.js";
+
+export { default as Ruleset } from "./rulesets/ruleset/Ruleset.js";
+export { Rule } from "./rulesets/ruleset/Ruleset.js";
+export default function (
+  plugins: Plugins,
+  parsers: Record<Scope, unknown>,
+  files: Record<Scope, string[]>,
+  rulesets: { [S in Scope]: Ruleset<S> },
+): IConfig[] {
+  try {
+    const instantiatedOptions: {
+      [S in Scope]: InstanceType<
+        typeof options[S]
+      >["body"]
+    } = {
+      js: new options
+        .js(
+          plugins
+            .js,
+          ...files
+            .js,
+        )
+        .body,
+      ts: new options
+        .ts(
+          plugins
+            .ts,
+          parsers
+            .ts,
+          ...files
+            .ts,
+        )
+        .body,
+      svelte: new options
+        .svelte(
+          plugins
+            .svelte,
+          parsers
+            .svelte,
+          parsers
+            .ts,
+          ...files
+            .svelte,
+        )
+        .body,
+      html: new options
+        .html(
+          plugins
+            .html,
+          parsers
+            .html,
+          ...files
+            .html,
+        )
+        .body,
+      json: new options
+        .json(
+          plugins
+            .json,
+          parsers
+            .json,
+          ...files
+            .json,
+        )
+        .body,
+      jsonc: new options
+        .jsonc(
+          plugins
+            .jsonc,
+          parsers
+            .jsonc,
+          ...files
+            .jsonc,
+        )
+        .body,
+      yml: new options
+        .yml(
+          plugins
+            .yml,
+          parsers
+            .yml,
+          ...files
+            .yml,
+        )
+        .body,
+    };
+
+    return scopes
+      .map(
+        scope =>
+          instantiatedOptions[scope].files.length > 0
+            ? rulesets[scope].flat.map(
+              rules => {
+                return {
+                  rules,
+                  ...instantiatedOptions[scope],
+                };
+              },
+            )
+            : [],
+      )
+      .flat();
+  }
+  catch (e) {
+    throw new Error(
+      `linted(): Caught exception.`,
+      { cause: e },
+    );
+  }
+}

package/src/options/HtmlOption.ts

@@ -0,0 +1,31 @@
+import Option from "./option/Option.js";
+
+export default class HtmlOption extends Option<
+  "html",
+  "@html-eslint",
+  true,
+  never,
+  never,
+  never,
+  never,
+  never
+> {
+  constructor(
+    plugins: HtmlOption["body"]["plugins"],
+    parser: HtmlOption["body"]["languageOptions"]["parser"],
+    ...files: string[]
+  ) {
+    super(
+      {
+        name: "linted/scope:html",
+        files,
+        plugins,
+        linterOptions: {
+          noInlineConfig: true,
+          reportUnusedDisableDirectives: "error",
+        },
+        languageOptions: { parser },
+      },
+    );
+  }
+}

package/src/options/JsOption.ts

@@ -0,0 +1,27 @@
+import Option from "./option/Option.js";
+
+export default class JsOption extends Option<
+  "js",
+  "@stylistic"
+> {
+  constructor(
+    plugins: JsOption["body"]["plugins"],
+    ...files: string[]
+  ) {
+    super(
+      {
+        name: "linted/scope:js",
+        files,
+        plugins,
+        linterOptions: {
+          noInlineConfig: true,
+          reportUnusedDisableDirectives: "error",
+        },
+        languageOptions: {
+          ecmaVersion: "latest",
+          sourceType: "module",
+        },
+      },
+    );
+  }
+}

package/src/options/JsonOption.ts

@@ -0,0 +1,31 @@
+import Option from "./option/Option.js";
+
+export default class JsonOption extends Option<
+  "json",
+  "jsonc",
+  true,
+  never,
+  never,
+  never,
+  never,
+  never
+> {
+  constructor(
+    plugins: JsonOption["body"]["plugins"],
+    parser: JsonOption["body"]["languageOptions"]["parser"],
+    ...files: string[]
+  ) {
+    super(
+      {
+        name: "linted/scope:json",
+        files,
+        plugins,
+        linterOptions: {
+          noInlineConfig: true,
+          reportUnusedDisableDirectives: "error",
+        },
+        languageOptions: { parser },
+      },
+    );
+  }
+}

package/src/options/JsoncOption.ts

@@ -0,0 +1,31 @@
+import Option from "./option/Option.js";
+
+export default class JsoncOption extends Option<
+  "jsonc",
+  "jsonc",
+  true,
+  never,
+  never,
+  never,
+  never,
+  never
+> {
+  constructor(
+    plugins: JsoncOption["body"]["plugins"],
+    parser: JsoncOption["body"]["languageOptions"]["parser"],
+    ...files: string[]
+  ) {
+    super(
+      {
+        name: "linted/scope:jsonc",
+        files,
+        plugins,
+        linterOptions: {
+          noInlineConfig: true,
+          reportUnusedDisableDirectives: "error",
+        },
+        languageOptions: { parser },
+      },
+    );
+  }
+}

package/src/options/MdOption.ts

@@ -0,0 +1,31 @@
+import Option from "./option/Option.js";
+
+export default class MdOption extends Option<
+  "md",
+  "yml",
+  true,
+  never,
+  never,
+  never,
+  never,
+  never
+> {
+  constructor(
+    plugins: MdOption["body"]["plugins"],
+    parser: MdOption["body"]["languageOptions"]["parser"],
+    ...files: string[]
+  ) {
+    super(
+      {
+        name: "linted/scope:md",
+        files,
+        plugins,
+        linterOptions: {
+          noInlineConfig: true,
+          reportUnusedDisableDirectives: "error",
+        },
+        languageOptions: { parser },
+      },
+    );
+  }
+}

package/src/options/SvelteOption.ts

@@ -0,0 +1,47 @@
+import Option from "./option/Option.js";
+import type TsOption from "./TsOption.js";
+
+export default class SvelteOption extends Option<
+  "svelte",
+  | "svelte"
+  | keyof TsOption["body"]["plugins"]
+  ,
+  true,
+  & TsOption["body"]["languageOptions"]["parserOptions"]
+  & { parser: unknown }
+  & { extraFileExtensions: [".svelte"] },
+  never,
+  "svelte/svelte"
+> {
+  constructor(
+    plugins: SvelteOption["body"]["plugins"],
+    svelteParser: SvelteOption["body"]["languageOptions"]["parser"],
+    tsParser: SvelteOption["body"]["languageOptions"]["parserOptions"]["parser"],
+    ...files: string[]
+  ) {
+    super(
+      {
+        name: "linted/scope:svelte",
+        processor: "svelte/svelte",
+        files,
+        plugins,
+        linterOptions: {
+          noInlineConfig: true,
+          reportUnusedDisableDirectives: "error",
+        },
+        languageOptions: {
+          ecmaVersion: "latest",
+          sourceType: "module",
+          parser: svelteParser,
+          parserOptions: {
+            ecmaVersion: "latest",
+            sourceType: "module",
+            project: "tsconfig.json",
+            extraFileExtensions: [".svelte"],
+            parser: tsParser,
+          },
+        },
+      },
+    );
+  }
+}

package/src/options/TsOption.ts

@@ -0,0 +1,40 @@
+import Option from "./option/Option.js";
+import type JsOption from "./JsOption.js";
+
+export default class TsOption extends Option<
+  "ts",
+  | "@typescript-eslint"
+  | keyof JsOption["body"]["plugins"]
+  ,
+  true,
+  & JsOption["body"]["languageOptions"]
+  & { project: "tsconfig.json" }
+> {
+  constructor(
+    plugins: TsOption["body"]["plugins"],
+    parser: unknown,
+    ...files: string[]
+  ) {
+    super(
+      {
+        name: "linted/scope:ts",
+        files,
+        plugins,
+        linterOptions: {
+          noInlineConfig: true,
+          reportUnusedDisableDirectives: "error",
+        },
+        languageOptions: {
+          ecmaVersion: "latest",
+          sourceType: "module",
+          parser,
+          parserOptions: {
+            ecmaVersion: "latest",
+            sourceType: "module",
+            project: "tsconfig.json",
+          },
+        },
+      },
+    );
+  }
+}

package/src/options/YmlOption.ts

@@ -0,0 +1,31 @@
+import Option from "./option/Option.js";
+
+export default class YmlOption extends Option<
+  "yml",
+  "yml",
+  true,
+  never,
+  never,
+  never,
+  never,
+  never
+> {
+  constructor(
+    plugins: YmlOption["body"]["plugins"],
+    parser: YmlOption["body"]["languageOptions"]["parser"],
+    ...files: string[]
+  ) {
+    super(
+      {
+        name: "linted/scope:yml",
+        files,
+        plugins,
+        linterOptions: {
+          noInlineConfig: true,
+          reportUnusedDisableDirectives: "error",
+        },
+        languageOptions: { parser },
+      },
+    );
+  }
+}

package/src/options/option/Option.ts

@@ -0,0 +1,25 @@
+export default class Option<
+  Scope extends string,
+  PluginId extends string,
+  UseParser extends boolean = never,
+  ParserOptions extends object = never,
+  GlobalTypes extends string = never,
+  ProcessorId extends string = never,
+  Source extends IOLanguageSource.Source = "module",
+  Ecma extends number | IOLanguageEcma.Ecma = "latest",
+> {
+  constructor(
+    public readonly body: IOption<
+      `linted/scope:${literalful<Scope>}`,
+      true,
+      "error",
+      PluginId,
+      Ecma,
+      Source,
+      UseParser,
+      ParserOptions,
+      GlobalTypes,
+      ProcessorId
+    >,
+  ) {}
+}

package/src/options.ts

@@ -0,0 +1,17 @@
+import JsOption from "./options/JsOption.js";
+import TsOption from "./options/TsOption.js";
+import SvelteOption from "./options/SvelteOption.js";
+import HtmlOption from "./options/HtmlOption.js";
+import JsonOption from "./options/JsonOption.js";
+import JsoncOption from "./options/JsoncOption.js";
+import YmlOption from "./options/YmlOption.js";
+
+export default {
+  js: JsOption,
+  ts: TsOption,
+  svelte: SvelteOption,
+  html: HtmlOption,
+  json: JsonOption,
+  jsonc: JsoncOption,
+  yml: YmlOption,
+} satisfies Record<Scope, unknown>;

package/src/plugins.d.ts

@@ -0,0 +1,24 @@
+type PluginPackage = { configs: unknown };
+
+declare interface Plugins extends Record<
+  Scope,
+  Record<
+    string,
+    { configs: unknown }
+  >
+> {
+  js: { "@stylistic": PluginPackage };
+  ts: {
+    "@stylistic": PluginPackage;
+    "@typescript-eslint": PluginPackage;
+  };
+  svelte: {
+    "@stylistic": PluginPackage;
+    "@typescript-eslint": PluginPackage;
+    svelte: PluginPackage;
+  };
+  html: { "@html-eslint": PluginPackage };
+  json: { jsonc: PluginPackage };
+  jsonc: { jsonc: PluginPackage };
+  yml: { yml: PluginPackage };
+}

package/src/rulesets/ruleset/Ruleset.ts

@@ -0,0 +1,50 @@
+import Rule from "./rule/Rule.js";
+
+export { default as Rule } from "./rule/Rule.js";
+export default class Ruleset<Language extends string> {
+  public readonly ruleset: readonly Rule[];
+  public readonly overrides: Rule[] = [];
+
+  constructor(
+    protected readonly language: literalful<Language>,
+    ...ruleset: readonly Rule[]
+  ) {
+    this.ruleset = [...ruleset];
+  }
+
+  public get id() {
+    return `ruleset:${this.language}` as const;
+  }
+
+  public get flat() {
+    return [
+      ...this.ruleset.map(
+        rules =>
+          rules.rules,
+      ),
+      ...this.overrides.map(
+        rules =>
+          rules.rules,
+      ),
+    ];
+  }
+
+  public override(...overrides: (undefined | IRule)[]) {
+    this.overrides.push(
+      ...overrides
+        .filter(
+          override =>
+            typeof override !== "undefined",
+        )
+        .map(
+          override =>
+            new Rule(
+              "override",
+              override,
+            ),
+        ),
+    );
+
+    return this;
+  }
+}

package/src/rulesets/ruleset/rule/Rule.ts

@@ -0,0 +1,6 @@
+export default class Rule {
+  constructor(
+    public readonly id: string,
+    public readonly rules: IRule,
+  ) {}
+}

package/src/scopes.ts

@@ -0,0 +1,11 @@
+const scopes = [
+  "js",
+  "ts",
+  "svelte",
+  "html",
+  "json",
+  "jsonc",
+  "yml",
+] as const satisfies Scope[];
+
+export default scopes;

package/tsconfig.json

@@ -1,10 +1,12 @@
 {
   "display": "@jimbojet/tsc",
-  "_version": "5.5.7",
+  "_version": "5.5.8",
   "$schema": "https://json.schemastore.org/tsconfig",
   "include": [
-    "src/**/*.ts",
     "*.config.ts",
+    "src/**/*.ts",
+    "interface/**/*.d.ts",
+    "types/**/*.d.ts",
   ],
   "compilerOptions": {
     /* Visit https://aka.ms/tsconfig to read more about this file */