Support min/max limits in root selectors (#50)

* v3.14.0, Support min/max limits in root selectors

Author: MikeDabrowski

fileComposition.schema.json

@@ -61,7 +61,23 @@
               }
             ]
           },
-          "limit": { "type": "number" }
+          "limit": {
+            "oneOf": [
+              { "type": "number" },
+              {
+                "type": "object",
+                "additionalProperties": false,
+                "properties": {
+                  "min": {
+                    "type": "number"
+                  },
+                  "max": {
+                    "type": "number"
+                  }
+                }
+              }
+            ]
+          }
         },
         "required": ["limit", "selector"]
       }

package.json

@@ -1,7 +1,7 @@
 {
   "author": "Igor Kowalski (Igorkowalski94)",
   "name": "eslint-plugin-project-structure",
-  "version": "3.13.3",
+  "version": "3.14.0",
   "license": "MIT",
   "description": "Powerful ESLint plugin with rules to help you achieve a scalable, consistent, and well-structured project. Create your own framework! Define your folder structure, file composition, advanced naming conventions, and create independent modules. Take your project to the next level and save time by automating the review of key principles of a healthy project! react folder structure react file structure react project structure react conventions architecture react next.js angular node solid vue svelte",
   "keywords": [

src/rules/fileComposition/fileComposition.types.ts

@@ -66,7 +66,7 @@ type CustomErrors = Partial<Record<SelectorType, string>>;
 
 export interface RootSelectorLimit {
   selector: SelectorType | SelectorType[];
-  limit: number;
+  limit: number | { max?: number; min?: number };
 }
 
 export interface AllowOnlySpecifiedSelectors {

src/rules/fileComposition/helpers/getFileCompositionConfig/getFileCompositionConfig.consts.ts

@@ -63,7 +63,23 @@ export const FILE_COMPOSITION_SCHEMA: JSONSchema4 = {
               },
             ],
           },
-          limit: { type: "number" },
+          limit: {
+            oneOf: [
+              { type: "number" },
+              {
+                type: "object",
+                additionalProperties: false,
+                properties: {
+                  min: {
+                    type: "number",
+                  },
+                  max: {
+                    type: "number",
+                  },
+                },
+              },
+            ],
+          },
         },
         required: ["limit", "selector"],
       },

src/rules/fileComposition/helpers/validateRootSelectorsLimits/validateRootSelectorsLimits.test.ts

@@ -105,4 +105,83 @@ describe("validateRootSelectorsLimits", () => {
       },
     });
   });
+
+  describe("Limit objects", () => {
+    test("Should throw error when !!error", () => {
+      (getSelectorsCount as jest.Mock).mockReturnValue({
+        variable: 2,
+        variableExpression: 2,
+        arrowFunction: 2,
+        function: 3,
+        class: 3,
+        type: 2,
+        interface: 3,
+      });
+
+      const reportMock = jest.fn();
+
+      validateRootSelectorsLimits({
+        node: { body: {} } as TSESTree.Program,
+        report: reportMock,
+        rootSelectorsLimits: [
+          {
+            selector: ["interface", "type"],
+            limit: { min: 2, max: 3 },
+          },
+          {
+            selector: "variable",
+            limit: { max: 1 },
+          },
+          {
+            selector: "enum",
+            limit: { min: 3 },
+          },
+        ],
+      });
+
+      expect(reportMock).toHaveBeenCalledWith({
+        node: { body: {} },
+        messageId: "rootSelectorsLimits",
+        data: {
+          error:
+            "\nSelector: 'interface', 'type', min = 2, max = 3, occurrences = 5." +
+            "\nSelector: 'variable', max = 1, occurrences = 2." +
+            "\nSelector: 'enum', min = 3, occurrences = 0.",
+        },
+      });
+    });
+
+    test("Should return undefined when !error", () => {
+      (getSelectorsCount as jest.Mock).mockReturnValue({
+        variable: 2,
+        variableExpression: 2,
+        arrowFunction: 2,
+        function: 3,
+        class: 3,
+        type: 2,
+        interface: 3,
+      });
+
+      expect(
+        validateRootSelectorsLimits({
+          node: { body: {} } as TSESTree.Program,
+          report: jest.fn(),
+          rootSelectorsLimits: [
+            {
+              selector: ["interface", "type"],
+              limit: { min: 2, max: 5 },
+            },
+            {
+              selector: "variable",
+              limit: { max: 2 },
+            },
+            {
+              selector: "class",
+              limit: { min: 3 },
+            },
+          ],
+        }),
+      ).toEqual(undefined);
+    });
+  });
 });

src/rules/fileComposition/helpers/validateRootSelectorsLimits/validateRootSelectorsLimits.ts

@@ -28,8 +28,27 @@ export const validateRootSelectorsLimits = ({
       0,
     );
 
-    if (occurrences > limit)
-      return (acc += `\nSelector: ${selectorArray.map((s) => `'${s}'`).join(", ")}, limit = ${String(limit)}, occurrences = ${String(occurrences)}.`);
+    if (typeof limit === "number") {
+      if (occurrences > limit)
+        return (acc += `\nSelector: ${selectorArray.map((s) => `'${s}'`).join(", ")}, limit = ${String(limit)}, occurrences = ${String(occurrences)}.`);
+    }
+
+    if (typeof limit === "object") {
+      const { min, max } = limit;
+
+      if (
+        typeof min === "number" &&
+        typeof max === "number" &&
+        (occurrences < min || occurrences > max)
+      )
+        return (acc += `\nSelector: ${selectorArray.map((s) => `'${s}'`).join(", ")}, min = ${String(min)}, max = ${String(max)}, occurrences = ${String(occurrences)}.`);
+
+      if (typeof max === "number" && occurrences > max)
+        return (acc += `\nSelector: ${selectorArray.map((s) => `'${s}'`).join(", ")}, max = ${String(max)}, occurrences = ${String(occurrences)}.`);
+
+      if (typeof min === "number" && occurrences < min)
+        return (acc += `\nSelector: ${selectorArray.map((s) => `'${s}'`).join(", ")}, min = ${String(min)}, occurrences = ${String(occurrences)}.`);
+    }
 
     return acc;
   }, "");