1.4.7

.husky/pre-commit

@@ -3,9 +3,9 @@
 
 echo '🕵️‍♂️ Checking your crappy code 🕵️‍♂️'
 
-echo '🕵️‍♂️🕵️‍♂️🕵️‍♂️ dead-code:check 🕵️‍♂️🕵️‍♂️🕵️‍♂️'
-yarn dead-code:check || (echo '🤢🤮🤢 dead-code:check failed 🤢🤮🤢'; false)
-echo '✅✅✅ dead-code:check ✅✅✅'
+echo '🕵️‍♂️🕵️‍♂️🕵️‍♂️ deadCode:check 🕵️‍♂️🕵️‍♂️🕵️‍♂️'
+yarn deadCode:check || (echo '🤢🤮🤢 deadCode:check failed 🤢🤮🤢'; false)
+echo '✅✅✅ deadCode:check ✅✅✅'
 
 echo '🕵️‍♂️🕵️‍♂️🕵️‍♂️ lint:check 🕵️‍♂️🕵️‍♂️🕵️‍♂️'
 yarn lint:check || (echo '🤢🤮🤢 lint:check failed 🤢🤮🤢'; false);

jest.config.ts

@@ -1,6 +1,7 @@
 import type { JestConfigWithTsJest } from "ts-jest";
 
 const jestConfig: JestConfigWithTsJest = {
+    maxWorkers: "90%",
     testEnvironment: "node",
     transform: {
         "^.+\\.tsx?$": [

package.json

@@ -1,7 +1,7 @@
 {
     "author": "Igor Kowalski (Igorkowalski94)",
     "name": "eslint-plugin-project-structure",
-    "version": "1.4.6",
+    "version": "1.4.7",
     "license": "MIT",
     "description": "Eslint plugin that allows you to enforce rules on project structure. Folder and file naming, folder structure, file extensions all under your control to keep your repo consistent even in large teams.",
     "keywords": [
@@ -34,17 +34,16 @@
         "node": "^12.22.0 || ^14.17.0 || >=16.0.0"
     },
     "scripts": {
+        "clean": "del -rf dist",
         "build": "tsc -p tsconfig.build.json && node esbuild.config.js",
-        "dead-code:check": "ts-prune --error",
-        "types:check": "tsc",
         "format": "prettier --write --config .prettierrc.json .",
         "format:check": "prettier --check --config .prettierrc.json .",
-        "lint": "eslint src --max-warnings 0",
+        "deadCode:check": "ts-prune --error",
+        "types:check": "tsc",
         "lint:check": "eslint src --max-warnings 0",
-        "clean": "del -rf dist",
-        "test": "jest --coverage --watch",
         "test:check": "jest --coverage --watchAll=false --bail",
-        "test:current": "jest --coverage --changedSince=origin/main",
+        "test": "jest --coverage --watch",
+        "checkAll": "yarn deadCode:check && yarn format:check && yarn lint:check && yarn test:check",
         "husky:prepare": "husky install"
     },
     "dependencies": {

src/helpers/getNodeType.ts

@@ -1,5 +1,5 @@
-import { getIsFileFromNodeName } from "./getIsFileFromNodeName";
+import { isFileFromNodeName } from "./isFileFromNodeName";
 import { NodeType } from "../types";
 
 export const getNodeType = (nodeName: string): NodeType =>
-    getIsFileFromNodeName(nodeName) ? "File" : "Folder";
+    isFileFromNodeName(nodeName) ? "File" : "Folder";

src/helpers/isFileFromNodeName.ts

@@ -0,0 +1,2 @@
+export const isFileFromNodeName = (nodeName: string): boolean =>
+    nodeName.includes(".");

src/helpers/isFileFromPathname.test.ts

@@ -0,0 +1,15 @@
+import { isFileFromPathname } from "./isFileFromPathname";
+
+describe("isFileFromPathname", () => {
+    it("should return false when pathname includes /", () => {
+        expect(isFileFromPathname("src/componentName")).toEqual(false);
+    });
+
+    it("should return false when pathname includes \\", () => {
+        expect(isFileFromPathname("src\\componentName")).toEqual(false);
+    });
+
+    it("should return true when pathname not includes / or \\", () => {
+        expect(isFileFromPathname("componentName")).toEqual(true);
+    });
+});

src/helpers/isFileFromPathname.ts

@@ -0,0 +1,2 @@
+export const isFileFromPathname = (pathname: string): boolean =>
+    !(pathname.includes("/") || pathname.includes("\\"));

src/validators/validateChildren/helpers/filterRulesByType.ts

@@ -1,5 +1,5 @@
-import { getIsFileFromPathname } from "../../../helpers/getIsFileFromPathName";
 import { getNodeRule } from "../../../helpers/getNodeRule/getNodeRule";
+import { isFileFromPathname } from "../../../helpers/isFileFromPathname";
 import { ProjectStructureConfig, Rule } from "../../../types";
 
 export interface FilterRulesByType {
@@ -15,7 +15,7 @@ export const filterRulesByType = ({
 }: FilterRulesByType): boolean => {
     const nodeRule = getNodeRule(rule, config);
 
-    const isFile = getIsFileFromPathname(pathname);
+    const isFile = isFileFromPathname(pathname);
     const isFolderNode = !!nodeRule.children;
     const isFileNode = !!nodeRule.extension;
 

src/validators/validateName/helpers/getInvalidRegexError.ts

@@ -0,0 +1,4 @@
+import { FinalError } from "../../../errors/FinalError/FinalError";
+
+export const getInvalidRegexError = (regex: string): FinalError =>
+    new FinalError(`\n\n🔥 Regex: ${regex} is invalid. 🔥\n\n`);

src/validators/validateName/helpers/isRegex.ts

@@ -0,0 +1 @@
+export const isRegex = (regex: string): boolean => /^\/(.+)\/$/.test(regex);

src/validators/validateName/helpers/isRegexInvalid.ts

@@ -0,0 +1,9 @@
+export const isRegexInvalid = (regex: string): boolean => {
+    try {
+        new RegExp(regex);
+    } catch (e) {
+        return true;
+    }
+
+    return false;
+};

src/validators/validateName/validateName.test.ts

@@ -1,4 +1,5 @@
 import { getInvalidNameError } from "./helpers/getInvalidNameError";
+import { getInvalidRegexError } from "./helpers/getInvalidRegexError";
 import { getNameError } from "./helpers/getNameError";
 import { getNameRegexError } from "./helpers/validateRegexPattern/helpers/getNameRegexError";
 import { validateName } from "./validateName";
@@ -17,6 +18,16 @@ describe("validateName", () => {
         },
     );
 
+    it("should throw error when regex is invalid", () => {
+        expect(() =>
+            validateName({
+                nodeName: "componentName.api",
+                ruleName: "/^?/",
+                parentName: "parentName",
+            }),
+        ).toThrow(getInvalidRegexError("/^?/"));
+    });
+
     it("should not throw error when nodeName match regex", () => {
         expect(() =>
             validateName({

src/validators/validateName/validateName.ts

@@ -1,6 +1,8 @@
 import { getInvalidNameError } from "./helpers/getInvalidNameError";
-import { getIsRegex } from "./helpers/getIsRegex";
+import { getInvalidRegexError } from "./helpers/getInvalidRegexError";
 import { getNameError } from "./helpers/getNameError";
+import { isRegex } from "./helpers/isRegex";
+import { isRegexInvalid } from "./helpers/isRegexInvalid";
 import { validateRegexPattern } from "./helpers/validateRegexPattern/validateRegexPattern";
 import { RegexParameters } from "../../types";
 
@@ -18,8 +20,9 @@ export const validateName = ({
     regexParameters,
 }: ValidateName): void => {
     if (typeof ruleName !== "string") throw getInvalidNameError(ruleName);
+    if (isRegexInvalid(ruleName)) throw getInvalidRegexError(ruleName);
 
-    if (getIsRegex(ruleName))
+    if (isRegex(ruleName))
         return validateRegexPattern({
             nodeName,
             parentName,

src/validators/validatePath/helpers/getNodeName.ts

@@ -1,15 +1,15 @@
 import { sep } from "path";
 
 import { getFileNameWithoutExtension } from "./getFileNameWithoutExtension";
-import { getIsFileFromPathname } from "../../../helpers/getIsFileFromPathName";
+import { isFileFromPathname } from "../../../helpers/isFileFromPathname";
 
 interface GetNodeNameReturn {
     nodeName: string;
     fileNameWithExtension: string | undefined;
 }
 
 export const getNodeName = (pathname: string): GetNodeNameReturn => {
-    const isFile = getIsFileFromPathname(pathname);
+    const isFile = isFileFromPathname(pathname);
 
     const currentNodeName = pathname.split(sep)[0];