@eslinted/core 26.0.0 → 26.1.0-rc.1

package/src/factory.ts

@@ -1,89 +1,58 @@
 import type { Input } from "./interface";
 
-export class Factory<
+export default function factory<
   Scope extends string,
   OptionalScope extends Scope,
-  RequiredPlugin extends string,
-  RequiredParser extends Scope,
-> {
-  public globalConfigs;
-  public scopes;
-  public parsers;
-  private readonly settings;
-
-  constructor(
-    tree: Array<
-      readonly [
-        Scope,
-        readonly Scope[],
-      ]
-    >,
-    optionalScopes: readonly Scope[],
-    {
-      plugins,
-      parsers,
-    }: Input<
-      Scope,
-      OptionalScope,
-      RequiredPlugin,
-      RequiredParser
-    >["imports"],
-    defaults: Input<
-      Scope,
-      OptionalScope,
-      RequiredPlugin,
-      RequiredParser
-    >["configuration"]["defaults"],
-    extensions: Input<
+  BundledPlugin extends string,
+  BundledParser extends Scope,
+  // Tree,
+>(
+  scopes: readonly Scope[],
+  optionalScopes: readonly OptionalScope[],
+  tree: Array<
+    readonly [
       Scope,
-      OptionalScope,
-      RequiredPlugin,
-      RequiredParser
-    >["configuration"]["extensions"] = {},
-  ) {
-    this.settings = defaults.settings;
-
-    if ("svelte" in extensions && "plugin" in (extensions.svelte as object)) {
+      readonly Scope[],
+    ]
+  >,
+  {
+    plugins,
+    parsers,
+  }: {
+    plugins: Record<BundledPlugin, unknown>;
+    parsers: Record<BundledParser, unknown>;
+  },
+  defaults: Input<
+    Scope,
+    OptionalScope,
+    BundledPlugin,
+    BundledParser
+  >["configuration"]["defaults"],
+  extensions: Input<
+    Scope,
+    OptionalScope,
+    BundledPlugin,
+    BundledParser
+  >["configuration"]["extensions"] = {},
+) {
+  for (const scope of optionalScopes)
+    if (extensions[scope] !== undefined) {
       Object.assign(
         plugins,
         {
-          svelte: (extensions.svelte as { plugin: unknown }).plugin,
+          [scope]: extensions[scope].plugin,
         },
       );
       Object.assign(
         parsers,
         {
-          svelte: (extensions.svelte as { parser: unknown }).parser,
+          [scope]: extensions[scope].parser,
         },
       );
     }
 
-    const ignores = extensions["*"]?.override === true
-      ? extensions["*"].ignores ?? []
-      : defaults.ignores["*"].concat(extensions["*"]?.ignores ?? []);
-
-    this.globalConfigs = {
-      plugins: {
-        name: "linted/*/plugins",
-        plugins,
-      },
-      ignores: {
-        name: "linted/*/ignores",
-        ignores,
-      },
-    };
-    this.scopes = {
-      files: defaults.files,
-      ignores: defaults.ignores,
-      rules: defaults.rules,
-    };
-    this.parsers = parsers;
-
-    const extended = new Set<Scope>(Object.keys(extensions) as unknown[] as Scope[]);
-
-    extended.delete("*" as unknown as Scope);
-
-    for (const scope of extended) {
+  for (const scope of scopes)
+    if (extensions[scope] !== undefined) {
       const {
         [scope]: {
           files = [],
@@ -92,150 +61,212 @@ export class Factory<
         } = {},
       } = extensions;
 
-      if (files.length !== 0) {
-        const defaultFiles = this.scopes.files[scope],
-        fEnd = defaultFiles.length;
-
-        defaultFiles.length += files.length;
-
-        for (let i = 0; i < files.length; i++)
-          defaultFiles[fEnd + i] = files[i] as string;
-      }
-
-      if (ignores.length !== 0) {
-        const defaultIgnores = this.scopes.ignores[scope],
-        iEnd = defaultIgnores.length;
-
-        defaultIgnores.length += ignores.length;
-
-        for (let i = 0; i < ignores.length; i++)
-          defaultIgnores[iEnd + i] = ignores[i] as string;
-      }
+      if (files.length !== 0)
+        if (defaults.files[scope] === undefined)
+          Object.assign(
+            defaults.files,
+            { [scope]: files },
+          );
+        else {
+          const defaultFiles = defaults.files[scope],
+          L = defaultFiles.length;
+
+          defaultFiles.length += files.length;
+
+          for (let i = 0; i < files.length; i++)
+            defaultFiles[L + i] = files[i] as string;
+        }
+
+      if (ignores.length !== 0)
+        if (defaults.ignores[scope] === undefined)
+          Object.assign(
+            defaults.ignores,
+            { [scope]: ignores },
+          );
+        else {
+          const defaultIgnores = defaults.ignores[scope],
+          L = defaultIgnores.length;
+
+          defaultIgnores.length += ignores.length;
+
+          for (let i = 0; i < ignores.length; i++)
+            defaultIgnores[L + i] = ignores[i] as string;
+        }
 
       if (rules !== null)
-        this.scopes.rules[scope][
-          this.scopes.rules[scope].length
-        ] = {
-          id: scope.concat("/override"),
-          rules,
-        };
+        if (defaults.rules[scope] === undefined)
+          Object.assign(
+            defaults.rules,
+            {
+              [scope]: [
+                {
+                  id: scope.concat("/override"),
+                  rules,
+                },
+              ],
+            },
+          );
+        else
+        /* eslint-disable no-param-reassign */
+          defaults.rules[scope][
+            defaults.rules[scope].length
+          ] = {
+            id: scope.concat("/override"),
+            rules,
+          };
     }
 
-    const OptionalScopes = new Set<Scope>(optionalScopes);
+  const OptionalScope = new Set<Scope>(optionalScopes);
 
-    for (const [scope, parents] of tree)
-      if (
-        !OptionalScopes.has(scope)
-        || scope in this.parsers
-      ) {
-        const files = this.scopes.files[scope],
-        ignores = this.scopes.ignores[scope];
+  for (const [scope, parents] of tree)
+    if (
+      !OptionalScope.has(scope)
+      || scope in parsers
+    ) {
+      const files = defaults.files[scope],
+      ignores = defaults.ignores[scope];
 
+      if (files !== undefined)
         if (files.length !== 0)
-          for (const parent of parents) {
-            const parentFiles = this.scopes.files[parent],
-            fEnd = parentFiles.length;
-
-            parentFiles.length += files.length;
-
-            for (let i = 0; i < files.length; i++)
-              parentFiles[fEnd + i] = files[i] as string;
-          }
-
+          for (const parent of parents)
+            if (defaults.files[parent] === undefined)
+              Object.assign(
+                defaults.files,
+                { [parent]: files },
+              );
+            else {
+              const parentFiles = defaults.files[parent],
+              L = parentFiles.length;
+
+              parentFiles.length += files.length;
+
+              for (let i = 0; i < files.length; i++)
+                parentFiles[L + i] = files[i]!;
+            }
+
+      if (ignores !== undefined)
         if (ignores.length !== 0)
-          for (const parent of parents) {
-            const parentIgnores = this.scopes.ignores[parent],
-            iEnd = parentIgnores.length;
-
-            parentIgnores.length += ignores.length;
-
-            for (let i = 0; i < ignores.length; i++)
-              parentIgnores[iEnd + i] = ignores[i] as string;
-          }
-      }
-  }
-
-  public get globals() {
-    return [
-      this.globalConfigs.plugins,
-      this.globalConfigs.ignores,
-    ];
-  }
-
-  public scope(scope: Scope) {
-    const {
-      files: { [scope]: files },
-      ignores: { [scope]: ignores },
-      rules: { [scope]: rules },
-    } = this.scopes;
+          for (const parent of parents)
+            if (defaults.ignores[parent] === undefined)
+              Object.assign(
+                defaults.ignores,
+                { [parent]: ignores },
+              );
+            else {
+              const parentIgnores = defaults.ignores[parent],
+              L = parentIgnores.length;
+
+              parentIgnores.length += ignores.length;
+
+              for (let i = 0; i < ignores.length; i++)
+                parentIgnores[L + i] = ignores[i]!;
+            }
+    }
 
-    if (files.length === 0 || rules.length === 0)
-      return [];
-    else {
+  const configs: unknown[] = [
+    {
+      name: "linted/*/plugins",
+      plugins,
+    },
+    {
+      name: "linted/*/ignores",
+      ignores: extensions["*"]?.override === true
+        ? extensions["*"].ignores ?? []
+        : defaults.ignores["*"].concat(extensions["*"]?.ignores ?? []),
+    },
+  ],
+  scopeConfigs: unknown[] = scopes.flatMap(
+    scope => {
       const {
-        languageOptions = {},
-        parserOptions = {},
-        processor,
-        language,
-      } = this.settings[scope];
-
-      if ("parser" in languageOptions)
-        if (languageOptions.parser in this.parsers)
-          languageOptions.parser = this.parsers[languageOptions.parser as RequiredParser] as unknown as RequiredParser;
-        else
-          return [];
+        files: { [scope]: files },
+        ignores: { [scope]: ignores = [] },
+        rules: { [scope]: rules },
+        settings: { [scope]: settings },
+      } = defaults;
 
-      if ("parser" in parserOptions)
-        if (parserOptions.parser in this.parsers)
-          parserOptions.parser = this.parsers[parserOptions.parser as RequiredParser] as unknown as RequiredParser;
-        else
-          return [];
-
-      const manifest = {
-        name: "linted/".concat(scope),
-        files,
-        ignores,
-      };
-
-      if (Object.keys(parserOptions).length !== 0)
-        Object.assign(
-          languageOptions,
-          { parserOptions },
-        );
+      if (
+        files === undefined
+        || rules === undefined
+        || files.length === 0
+        || rules.length === 0
+        || OptionalScope.has(scope)
+        && !(scope in parsers)
+
+      )
+        return [];
+      else {
+        const manifest = {
+          name: "linted/".concat(scope),
+          files,
+          ignores,
+        };
 
-      if (Object.keys(languageOptions).length !== 0)
-        Object.assign(
-          manifest,
-          { languageOptions },
+        if (settings !== undefined) {
+          const {
+            languageOptions = {},
+            parserOptions,
+            processor,
+            language,
+          } = settings;
+
+          if (languageOptions.parser !== undefined)
+            languageOptions.parser = parsers[languageOptions.parser as BundledParser] as unknown as BundledParser;
+
+          if (parserOptions?.parser !== undefined)
+            parserOptions.parser = parsers[parserOptions.parser as BundledParser] as unknown as BundledParser;
+
+          if (parserOptions !== undefined && Object.keys(parserOptions).length !== 0)
+            Object.assign(
+              languageOptions,
+              { parserOptions },
+            );
+
+          if (Object.keys(languageOptions).length !== 0)
+            Object.assign(
+              manifest,
+              { languageOptions },
+            );
+
+          if (processor !== undefined)
+            Object.assign(
+              manifest,
+              { processor },
+            );
+
+          if (language !== undefined)
+            Object.assign(
+              manifest,
+              { language },
+            );
+        }
+
+        return [manifest].concat(
+          rules.map(
+            (
+              {
+                id,
+                rules,
+              },
+            ) => ({
+              name: "linted/".concat(scope, "/", id),
+              files,
+              ignores,
+              rules,
+            }),
+          ),
         );
+      }
+    },
+  );
 
-      if (processor !== undefined)
-        Object.assign(
-          manifest,
-          { processor },
-        );
+  if (scopeConfigs.length !== 0) {
+    const L = configs.length;
 
-      if (language !== undefined)
-        Object.assign(
-          manifest,
-          { language },
-        );
+    configs.length += scopeConfigs.length;
 
-      return [manifest].concat(
-        rules.map(
-          (
-            {
-              id,
-              rules,
-            },
-          ) => ({
-            name: "linted/".concat(scope, "/", id),
-            files,
-            ignores,
-            rules,
-          }),
-        ),
-      );
-    }
+    for (let i = 0; i < scopeConfigs.length; i++)
+      configs[L + i] = scopeConfigs[i];
   }
+
+  return configs;
 }

package/src/index.ts

@@ -1,14 +1,14 @@
 import type { Input } from "./interface";
 import type {
-  RequiredPlugin,
-  RequiredParser,
+  BundledPlugin,
+  BundledParser,
 } from "./scope";
 import {
   scopes,
   optionalScopes,
   tree,
 } from "./scope";
-import { Factory } from "./factory";
+import factory from "./factory";
 
 export default function (
   {
@@ -20,27 +20,16 @@ export default function (
   }: Input<
     (typeof scopes[number]),
     (typeof optionalScopes[number]),
-    RequiredPlugin,
-    RequiredParser
+    BundledPlugin,
+    BundledParser
   >,
 ) {
-  const factory = new Factory<
-    (typeof scopes[number]),
-    (typeof optionalScopes[number]),
-    RequiredPlugin,
-    RequiredParser
-  >(
-    tree,
+  return factory(
+    scopes,
     optionalScopes,
+    tree,
     imports,
     defaults,
     extensions,
   );
-
-  return (factory.globals as unknown[])
-    .concat(
-      scopes.flatMap(
-        scope => factory.scope(scope),
-      ),
-    );
 }

package/src/interface/configuration/defaults/index.ts

@@ -5,26 +5,28 @@ export interface Defaults<
   Scope extends string,
   Parser extends Scope,
 > {
-  settings: Settings<
+  settings: Partial<Settings<
     Scope,
     Parser
-  >;
-  files: Record<
+  >>;
+  files: Partial<Record<
     Scope,
     string[]
-  >;
-  ignores: Record<
-    (
-      | "*"
-      | Scope
-    ),
-    string[]
-  >;
-  rules: Record<
+  >>;
+  ignores:
+    & Record<
+      "*",
+      string[]
+    >
+    & Partial<Record<
+      Scope,
+      string[]
+    >>;
+  rules: Partial<Record<
     Scope,
     {
       id: string;
       rules: Rules;
     }[]
-  >;
+  >>;
 }

package/src/interface/configuration/extensions/index.ts

@@ -5,5 +5,5 @@ export type Extensions<
   Scope extends string,
   OptionalScope extends Scope,
 >
-= & Partial<GlobalExtension>
-  & Partial<ScopeExtensions<Scope, OptionalScope>>;
+= & GlobalExtension
+  & ScopeExtensions<Scope, OptionalScope>;

package/src/interface/configuration/index.ts

@@ -10,8 +10,10 @@ export interface Configuration<
     Scope,
     Parser
   >;
-  extensions: Extensions<
-    Scope,
-    OptionalScope
+  extensions: Partial<
+    Extensions<
+      Scope,
+      OptionalScope
+    >
   >;
 }

package/src/interface/imports.ts

@@ -1,13 +1,13 @@
 export interface Imports<
-  RequiredPlugin extends string,
-  RequiredParser extends string,
+  BundledPlugin extends string,
+  BundledParser extends string,
 > {
   plugins: Record<
-    RequiredPlugin,
+    BundledPlugin,
     unknown
   >;
   parsers: Record<
-    RequiredParser,
+    BundledParser,
     unknown
   >;
 }

package/src/interface/index.ts

@@ -4,18 +4,18 @@ import type { Configuration } from "./configuration";
 export interface Input<
   Scope extends string,
   OptionalScope extends Scope,
-  RequiredPlugin extends string,
-  RequiredParser extends Scope,
+  BundledPlugin extends string,
+  BundledParser extends Scope,
 > {
   imports: Imports<
-    RequiredPlugin,
-    RequiredParser
+    BundledPlugin,
+    BundledParser
   >;
   configuration: Configuration<
     Scope,
     OptionalScope,
     (
-      | RequiredParser
+      | BundledParser
       | OptionalScope
     )
   >;

package/src/scope/dependencies/index.ts

@@ -1,2 +1,2 @@
-export type { RequiredPlugin } from "./plugins";
-export type { RequiredParser } from "./parsers";
+export type { BundledPlugin } from "./plugins";
+export type { BundledParser } from "./parsers";

package/src/scope/dependencies/parsers.ts

@@ -1,4 +1,4 @@
-export type RequiredParser
+export type BundledParser
 = | "ts"
   | "html"
   | "yml";

package/src/scope/dependencies/plugins.ts

@@ -1,4 +1,4 @@
-export type RequiredPlugin
+export type BundledPlugin
 = | "@stylistic"
   | "@typescript-eslint"
   | "mocha"

package/src/scope/index.ts

@@ -13,6 +13,6 @@ export const scopes = [
 export const optionalScopes = ["svelte"] as const;
 export { tree } from "./tree";
 export type {
-  RequiredPlugin,
-  RequiredParser,
+  BundledPlugin,
+  BundledParser,
 } from "./dependencies";

package/src/scope/{tree/index.spec.ts → tree.spec.ts}

@@ -1,5 +1,5 @@
 import "chai/register-should.js";
-import { tree } from ".";
+import { tree } from "./tree";
 
 const nodes = tree.map(([scope]) => scope);
 

package/dist/scope/tree/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/scope/tree/index.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,IAAI,qMAqBhB,CAAC"}

package/dist/scope/tree/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/scope/tree/index.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,MAAM,IAAI,GAAG;IAClB;QACE,QAAQ;QACR,CAAC,OAAO,CAAC;KACD;IACV;QACE,OAAO;QACP,CAAC,MAAM,CAAC;KACA;IACV;QACE,OAAO;QACP,CAAC,IAAI,CAAC;KACE;IACV;QACE,QAAQ;QACR,CAAC,IAAI,CAAC;KACE;IACV;QACE,IAAI;QACJ,CAAC,IAAI,CAAC;KACE;CACX,CAAC"}

package/dist/scope/tree/index.spec.d.ts

@@ -1,2 +0,0 @@
-import "chai/register-should.js";
-//# sourceMappingURL=index.spec.d.ts.map