@eslinted/defaults 12.18.0 → 12.19.0

package/src/index.spec.ts

@@ -0,0 +1,228 @@
+import "chai/register-should.js";
+import { defaults } from ".";
+
+describe(
+  "Main Export",
+  function () {
+    const SCOPE = [
+      "js",
+      "ts",
+    ],
+    GLOBAL_SCOPE = "*",
+    {
+      ignores,
+      files,
+      rules,
+    } = defaults;
+
+    describe(
+      "module",
+      function () {
+        it(
+          "with object submodules: ignores, files, rules",
+          function () {
+            ignores
+              .should
+              .be
+              .an("object");
+            files
+              .should
+              .be
+              .an("object");
+            rules
+              .should
+              .be
+              .an("object");
+          },
+        );
+      },
+    );
+    describe(
+      "submodule: ignores",
+      function () {
+        it(
+          "has scopes",
+          function () {
+            for (const scope of SCOPE)
+              ignores
+                .should
+                .have
+                .own
+                .property(scope);
+          },
+        );
+        it(
+          "has global scope",
+          function () {
+            ignores
+              .should
+              .have
+              .own
+              .property(GLOBAL_SCOPE);
+          },
+        );
+        it(
+          "of arrays",
+          function () {
+            for (const scope of Object.values(ignores))
+              scope
+
+                .should
+                .be
+                .an("array");
+          },
+        );
+        it(
+          "of strings",
+          function () {
+            for (const scope of Object.values(ignores))
+              for (const pattern of scope)
+                pattern
+                  .should
+                  .be
+                  .a("string");
+          },
+        );
+        it(
+          "with at least one global ignore pattern",
+          function () {
+            ignores[GLOBAL_SCOPE]
+              .should
+              .have
+              .lengthOf
+              .above(0);
+          },
+        );
+      },
+    );
+    describe(
+      "submodule: files",
+      function () {
+        it(
+          "has scopes",
+          function () {
+            for (const scope of SCOPE)
+              files
+                .should
+                .have
+                .own
+                .property(scope);
+          },
+        );
+        it(
+          "NO global scope",
+          function () {
+            files
+              .should
+              .not
+              .have
+              .own
+              .property(GLOBAL_SCOPE);
+          },
+        );
+        it(
+          "of arrays",
+          function () {
+            for (const scope of Object.values(files))
+              scope
+
+                .should
+                .be
+                .an("array");
+          },
+        );
+        it(
+          "of strings",
+          function () {
+            for (const scope of Object.values(files))
+              for (const pattern of scope)
+                pattern
+                  .should
+                  .be
+                  .a("string");
+          },
+        );
+      },
+    );
+    describe(
+      "submodule: rules",
+      function () {
+        it(
+          "has scopes",
+          function () {
+            for (const scope of SCOPE)
+              rules
+                .should
+                .have
+                .own
+                .property(scope);
+          },
+        );
+        it(
+          "NO global scope",
+          function () {
+            rules
+              .should
+              .not
+              .have
+              .own
+              .property(GLOBAL_SCOPE);
+          },
+        );
+        it(
+          "of arrays",
+          function () {
+            for (const scope of Object.values(files))
+              scope
+
+                .should
+                .be
+                .an("array");
+          },
+        );
+        it(
+          "of object",
+          function () {
+            for (const scope of Object.values(rules))
+              for (const rule of scope)
+                rule
+                  .should
+                  .be
+                  .an("object");
+          },
+        );
+        it(
+          "named rulesets",
+          function () {
+            for (const scope of Object.values(rules))
+              for (const rule of scope) {
+                rule
+                  .should
+                  .have
+                  .keys(
+                    "id",
+                    "rules",
+                  );
+                rule
+                  .id
+                  .should
+                  .be
+                  .a("string");
+                rule
+                  .rules
+                  .should
+                  .be
+                  .an("object");
+
+                for (const key of Object.keys(rule.rules))
+                  key
+                    .should
+                    .be
+                    .a("string");
+              }
+          },
+        );
+      },
+    );
+  },
+);

package/src/index.ts

@@ -4,7 +4,7 @@ import { rules } from "./rules";
 
 export { settings } from "./settings";
 export const defaults = {
-  files,
   ignores,
+  files,
   rules,
 };

package/src/rules/_strings/option.ts

@@ -25,6 +25,5 @@ never = "never",
 none = "none",
 outside = "outside",
 single = "single",
-wildcard = "*",
 strict = "strict",
-zebra = "zebra";
+wildcard = "*";

package/src/rules/_strings/state.spec.ts

@@ -1,45 +1,45 @@
 import "chai/register-should.js";
 import * as State from "./state";
 
-const state = { ...State };
-
 describe(
-  "Strings:Level",
+  "Strings: State",
   function () {
+    const state = { ...State };
+
     describe(
       "shape",
       function () {
         it(
-          "is module (converted to object)",
+          "is object module",
           function () {
             state
-              .should.be
+              .should
+              .be
               .an("object");
           },
         );
       },
     );
     describe(
-      "count",
+      "keys",
       function () {
+        const keys = Object.keys(state);
+
         it(
-          "is 3",
+          "count 3",
           function () {
-            Object.keys(state)
-              .should.have
+            keys
+              .should
+              .have
               .lengthOf(3);
           },
         );
-      },
-    );
-    describe(
-      "unique count",
-      function () {
         it(
-          "is 3",
+          "unique count 3",
           function () {
-            new Map(Object.entries(state))
-              .should.have
+            new Set(keys)
+              .should
+              .have
               .lengthOf(3);
           },
         );
@@ -49,13 +49,18 @@ describe(
       "values",
       function () {
         it(
-          "are: error | warn | off",
+          "off(0) | warn(1) | error(2)",
           function () {
-            new Map(Object.entries(state))
+            new Set(Object.values(state))
               .should
-              .include("error")
-              .and.include("warn")
-              .and.include("off");
+              .have
+              .members(
+                [
+                  0,
+                  1,
+                  2,
+                ],
+              );
           },
         );
       },

package/src/rules/_strings/state.ts

@@ -1,4 +1,4 @@
 export const
-OFF = "off",
-ON = "error",
-WARN = "warn";
+OFF = 0,
+WARN = 1,
+ON = 2;

package/src/rules/yml/enable.ts

@@ -27,6 +27,6 @@ export const YmlEnablePlugin = {
     "yml/require-string-key": ON,
     // "yml/sort-keys": OFF,
     // "yml/sort-sequence-values": OFF,
-    "yml/vue-custom-block/no-parsing-error": ON,
+    // "yml/vue-custom-block/no-parsing-error": OFF /* I don't use Vue and I plan to continue not using it if I can help it */,
   } as const,
 };