@eslinted/core 18.9.4 → 18.10.1

package/src/index.spec.ts

@@ -1,51 +1,106 @@
-import { expect } from "chai";
+import "chai/register-should.js";
 import core from ".";
 import { scopes } from "./scopes";
-import { TestInput } from "./index.input.spec";
+import { TestInput } from "./test/input";
 
 const configs = core(TestInput);
 
-describe("Core", function () {
-  describe("shape", function () {
-    it("is a function", function () {
-      expect(core)
-        .a("function");
-    });
-  });
-  describe("output", function () {
-    it("is a non-empty array", function () {
-      expect(configs)
-        .an("array")
-        .not.empty;
-    });
-    it(`with length >= plugins + */ignores + */settings + ${scopes.length} scopes = ${scopes.length + 3}  [Actual: ${configs.length}`, function () {
-      expect(configs)
-        .lengthOf.above(scopes.length + 2);
-    });
-    it("containing only config-like members", function () {
-      expect(configs)
-        .satisfies((configs: unknown[]) => configs.every(config => typeof config === "object" && config !== null && "name" in config && typeof config.name === "string"));
-    });
-  });
-  describe("configs", function () {
-    it("begin with plugins", function () {
-      expect(configs[0])
-        .has.property("name", "linted/*/plugins/");
-      expect(configs[0])
-        .has.property("plugins")
-        .an("object");
-    });
-    it("followed by global settings", function () {
-      expect(configs[1])
-        .has.property("name", "linted/*/settings/");
-      expect(configs[1])
-        .has.property("linterOptions")
-        .an("object");
-      expect(configs[1])
-        .has.nested.property("languageOptions.sourceType")
-        .a("string");
-      expect(configs[1])
-        .has.nested.property("languageOptions.ecmaVersion");
-    });
-  });
-});
+describe(
+  "Core",
+  function () {
+    describe(
+      "shape",
+      function () {
+        it(
+          "is a function",
+          function () {
+            core
+              .should.be
+              .a("function");
+          },
+        );
+      },
+    );
+    describe(
+      "output",
+      function () {
+        it(
+          "is a non-empty array",
+          function () {
+            configs
+              .should.be
+              .an("array")
+              .not.empty;
+          },
+        );
+        it(
+          `with length >= plugins + */ignores + */settings + ${scopes.length} scopes = ${scopes.length + 3}  [Actual: ${configs.length}`,
+          function () {
+            configs
+              .should.have
+              .lengthOf.above(scopes.length + 2);
+          },
+        );
+        it(
+          "containing only config-like members",
+          function () {
+            configs
+              .should
+              .satisfy((configs: unknown[]) => configs
+                .every(config => typeof config === "object"
+                  && config !== null
+                  && "name" in config
+                  && typeof config.name === "string"));
+          },
+        );
+      },
+    );
+    describe(
+      "configs",
+      function () {
+        const [
+          first,
+          second,
+        ] = configs as [object, object];
+
+        it(
+          "begin with plugins",
+          function () {
+            first
+              .should.have
+              .property(
+                "name",
+                "linted/*/plugins/",
+              );
+            first
+              .should.have
+              .property("plugins")
+              .an("object");
+          },
+        );
+        it(
+          "followed by global settings",
+          function () {
+            second
+              .should.have
+              .property(
+                "name",
+                "linted/*/settings/",
+              );
+            second
+              .should.have
+              .property("linterOptions")
+              .an("object");
+            second
+              .should.have
+              .nested.property("languageOptions.sourceType")
+              .a("string");
+            second
+              .should.have
+              .nested.property("languageOptions.ecmaVersion");
+          },
+        );
+      },
+    );
+  },
+);

package/src/index.ts

@@ -2,23 +2,46 @@ import type { Input, Output } from "./interface";
 import { scopes, tree } from "./scopes";
 import { Factory } from "./factory";
 
-export type * from "./interface";
+export type * from "./interface/input";
+export type * from "./interface/proto";
 export type * from "./scopes";
-export default function ({
-  imports: { plugins, parsers },
-  defaults,
-  extensions,
-}: Input): Output {
+export default function (
+  {
+    imports: {
+      plugins,
+      parsers,
+    },
+    defaults,
+    extensions,
+  }: Input,
+) {
   try {
-    const factory = new Factory(tree, parsers, defaults, extensions);
+    const factory = new Factory(
+      tree,
+      parsers,
+      defaults,
+      extensions,
+    );
 
     return [
-      { name: "linted/*/plugins/", plugins } as const,
+      {
+        name: "linted/*/plugins/",
+        plugins,
+      },
       ...factory.globals,
-      ...scopes.flatMap(scope => factory.scope(scope)),
-    ] as const;
+      ...scopes
+        .flatMap(
+          scope => factory
+            .scope(
+              scope,
+            ),
+        ),
+    ] satisfies Output satisfies unknown[] as unknown[];
   }
   catch (e) {
-    throw new Error(`Linted Core`, { cause: e });
+    throw new Error(
+      "linted-core: ",
+      { cause: e },
+    );
   }
 }

package/src/scopes/index.spec.ts

@@ -1,43 +1,128 @@
-import { expect } from "chai";
+import "chai/register-should.js";
 import { scopes } from ".";
 
-describe("Scopes", function () {
-  describe("shape", function () {
-    it("is a non-empty array", function () {
-      expect(scopes)
-        .an("array")
-        .not.empty;
-    });
-  });
-  describe("members", function () {
-    it("are unique", function () {
-      expect(scopes.length)
-        .equals(new Set(scopes).size);
-    });
-  });
-  describe("order", function () {
-    it("`jsonc` > `json`", function () {
-      expect(scopes)
-        .includes.members(["jsonc", "json"]);
-      expect(scopes.indexOf("jsonc"))
-        .greaterThan(scopes.indexOf("json"));
-    });
-    it("`mocha` > `ts`", function () {
-      expect(scopes)
-        .includes.members(["mocha", "ts"]);
-      expect(scopes.indexOf("mocha"))
-        .greaterThan(scopes.indexOf("ts"));
-    });
-    it("`svelte` > `ts`", function () {
-      expect(scopes).includes.members(["svelte", "ts"]);
-      expect(scopes.indexOf("svelte"))
-        .greaterThan(scopes.indexOf("ts"));
-    });
-    it("`ts` > `js`", function () {
-      expect(scopes)
-        .includes.members(["ts", "js"]);
-      expect(scopes.indexOf("ts"))
-        .greaterThan(scopes.indexOf("js"));
-    });
-  });
-});
+describe(
+  "Scopes",
+  function () {
+    describe(
+      "shape",
+      function () {
+        it(
+          "is a non-empty array",
+          function () {
+            scopes
+              .should.be
+              .an("array")
+              .not.empty;
+          },
+        );
+      },
+    );
+    describe(
+      "members",
+      function () {
+        it(
+          "are unique",
+          function () {
+            scopes
+              .length
+              .should
+              .equal(
+                new Set(scopes)
+                  .size,
+              );
+          },
+        );
+      },
+    );
+    describe(
+      "order",
+      function () {
+        it(
+          "`jsonc` > `json`",
+          function () {
+            scopes
+              .should
+              .include
+              .members(
+                [
+                  "jsonc",
+                  "json",
+                ],
+              );
+            scopes
+              .indexOf("jsonc")
+              .should.be
+              .greaterThan(
+                scopes
+                  .indexOf("json"),
+              );
+          },
+        );
+        it(
+          "`mocha` > `ts`",
+          function () {
+            scopes
+              .should
+              .include
+              .members(
+                [
+                  "mocha",
+                  "ts",
+                ],
+              );
+            scopes
+              .indexOf("mocha")
+              .should.be
+              .greaterThan(
+                scopes
+                  .indexOf("ts"),
+              );
+          },
+        );
+        it(
+          "`svelte` > `ts`",
+          function () {
+            scopes
+              .should
+              .include
+              .members(
+                [
+                  "svelte",
+                  "ts",
+                ],
+              );
+            scopes
+              .indexOf("svelte")
+              .should.be
+              .greaterThan(
+                scopes
+                  .indexOf("ts"),
+              );
+          },
+        );
+        it(
+          "`ts` > `js`",
+          function () {
+            scopes
+              .should
+              .include
+              .members(
+                [
+                  "ts",
+                  "js",
+                ],
+              );
+            scopes
+              .indexOf("ts")
+              .should.be
+              .greaterThan(
+                scopes
+                  .indexOf("js"),
+              );
+          },
+        );
+      },
+    );
+  },
+);

package/src/scopes/tree/index.spec.ts

@@ -1,48 +1,122 @@
-import { expect } from "chai";
+import "chai/register-should.js";
 import { tree } from ".";
 
 const nodes = tree.map(([scope]) => scope);
 
-describe("Scope Tree", function () {
-  describe("shape", function () {
-    it("is an array", function () {
-      expect(tree)
-        .an("array");
-    });
-  });
-  describe("members", function () {
-    it("are unique", function () {
-      expect(tree.length)
-        .equals(new Set(nodes).size);
-    });
-    it("omit `js`", function () {
-      expect(nodes)
-        .to.not.include.members(["js"]);
-    });
-  });
-  describe("order", function () {
-    it("`jsonc` < [`json`]?", function () {
-      expect(nodes)
-        .includes.members(["jsonc"]);
-      expect(nodes.indexOf("jsonc"))
-        .lessThan(-nodes.indexOf("json") * tree.length);
-    });
-    it("`mocha` < `ts`", function () {
-      expect(nodes)
-        .includes.members(["mocha", "ts"]);
-      expect(nodes.indexOf("mocha"))
-        .lessThan(nodes.indexOf("ts"));
-    });
-    it("`svelte` < `ts`", function () {
-      expect(nodes).includes.members(["svelte", "ts"]);
-      expect(nodes.indexOf("svelte"))
-        .lessThan(nodes.indexOf("ts"));
-    });
-    it("`ts` is last", function () {
-      expect(nodes)
-        .includes.members(["ts"]);
-      expect(nodes.indexOf("ts"))
-        .equals(tree.length - 1);
-    });
-  });
-});
+describe(
+  "Scope Tree",
+  function () {
+    describe(
+      "shape",
+      function () {
+        it(
+          "is an array",
+          function () {
+            tree
+              .should.be
+              .an("array");
+          },
+        );
+      },
+    );
+    describe(
+      "members",
+      function () {
+        it(
+          "are unique",
+          function () {
+            tree
+              .length
+              .should
+              .equal(
+                new Set(nodes)
+                  .size,
+              );
+          },
+        );
+        it(
+          "omit `js`",
+          function () {
+            nodes
+              .should
+              .not.include
+              .members(["js"]);
+          },
+        );
+      },
+    );
+    describe(
+      "order",
+      function () {
+        it(
+          "`jsonc` < [`json`]?",
+          function () {
+            nodes
+              .should
+              .include
+              .members(["jsonc"]);
+            nodes
+              .indexOf("jsonc")
+              .should.be
+              .lessThan(-nodes.indexOf("json") * tree.length);
+          },
+        );
+        it(
+          "`mocha` < `ts`",
+          function () {
+            nodes
+              .should
+              .include
+              .members(
+                [
+                  "mocha",
+                  "ts",
+                ],
+              );
+            nodes
+              .indexOf("mocha")
+              .should.be
+              .lessThan(
+                nodes
+                  .indexOf("ts"),
+              );
+          },
+        );
+        it(
+          "`svelte` < `ts`",
+          function () {
+            nodes
+              .should
+              .include
+              .members(
+                [
+                  "svelte",
+                  "ts",
+                ],
+              );
+            nodes
+              .indexOf("svelte")
+              .should.be
+              .lessThan(
+                nodes
+                  .indexOf("ts"),
+              );
+          },
+        );
+        it(
+          "`ts` is last",
+          function () {
+            nodes
+              .should
+              .include
+              .members(["ts"]);
+            nodes
+              .indexOf("ts")
+              .should
+              .equal(tree.length - 1);
+          },
+        );
+      },
+    );
+  },
+);