style(rule): Resolve linter issue

Author: rizqyfahmi

src/index.ts

@@ -1,10 +1,10 @@
-import { type Plugin } from '@commitlint/types';
-import { default as scopePattern } from "./rules/scope-pattern";
+import { type Plugin } from "@commitlint/types"
+import { default as scopePattern } from "./rules/scope-pattern"
 
-export const rules: Plugin['rules'] = {
-    'commitlint-plugin-prevenger/scope-pattern': scopePattern,
-};
+export const rules: Plugin["rules"] = {
+    "commitlint-plugin-prevenger/scope-pattern": scopePattern,
+}
 
 export default {
-    rules,
-};
+    rules
+}

src/rules/scope-pattern/index.test.ts

@@ -1,12 +1,12 @@
-import type { Commit } from 'conventional-commits-parser';
-import type { Rule } from '@commitlint/types';
+import type { Commit } from "conventional-commits-parser"
+import type { Rule } from "@commitlint/types"
 import rule from "."
 
-describe('scope-pattern', () => {
+describe("scope-pattern", () => {
     const ruleFn = rule as Rule<[string, string?]>
     const createCommit = (scope?: string): Commit => {
         return {
-            type: 'feat',
+            type: "feat",
             scope: scope,
             header: `feat(${scope}): some message`,
             body: null,
@@ -17,45 +17,45 @@ describe('scope-pattern', () => {
             notes: [] as Commit.Note[],
             references: [] as Commit.Reference[]
         } as Commit
-    };
-
-    it('passes when scope matches pattern and "always" is used', async () => {
-        const result = await ruleFn(createCommit('core'), 'always', ['^core$']);
-        expect(result).toEqual([true, '']);
-    });
-
-    it('fails when scope does not match pattern and "always" is used', async () => {
-        const result = await ruleFn(createCommit('utils'), 'always', ['^core$']);
-        expect(result).toEqual([false, 'scope must match pattern: ^core$']);
-    });
-
-    it('passes when scope does not match pattern and "never" is used', async () => {
-        const result = await ruleFn(createCommit('utils'), 'never', ['^core$']);
-        expect(result).toEqual([true, '']);
-    });
-
-    it('fails when scope matches pattern and "never" is used', async () => {
-        const result = await ruleFn(createCommit('core'), 'never', ['^core$']);
-        expect(result).toEqual([false, 'scope must not match pattern: ^core$']);
-    });
-
-    it('passes when scope is undefined', async () => {
-        const result = await ruleFn(createCommit(undefined), 'always', ['^core$']);
-        expect(result).toEqual([true, '']);
-    });
-
-    it('uses default "when" and "value" when not provided', async () => {
-        const result = await ruleFn(createCommit('anyscope'));
-        expect(result).toEqual([true, '']);
-    });
-
-    it('uses default "value" when only "when" is provided', async () => {
-        const result = await ruleFn(createCommit('anyscope'), 'always');
-        expect(result).toEqual([true, '']);
-    });
-
-    it('uses custom message when provided and fails', async () => {
-        const result = await ruleFn(createCommit('utils'), 'always', ['^core$', 'Custom message']);
-        expect(result).toEqual([false, 'Custom message']);
-    });
-});
+    }
+
+    it("passes when scope matches pattern and \"always\" is used", async () => {
+        const result = await ruleFn(createCommit("core"), "always", ["^core$"])
+        expect(result).toEqual([true, ""])
+    })
+
+    it("fails when scope does not match pattern and \"always\" is used", async () => {
+        const result = await ruleFn(createCommit("utils"), "always", ["^core$"])
+        expect(result).toEqual([false, "scope must match pattern: ^core$"])
+    })
+
+    it("passes when scope does not match pattern and \"never\" is used", async () => {
+        const result = await ruleFn(createCommit("utils"), "never", ["^core$"])
+        expect(result).toEqual([true, ""])
+    })
+
+    it("fails when scope matches pattern and \"never\" is used", async () => {
+        const result = await ruleFn(createCommit("core"), "never", ["^core$"])
+        expect(result).toEqual([false, "scope must not match pattern: ^core$"])
+    })
+
+    it("passes when scope is undefined", async () => {
+        const result = await ruleFn(createCommit(undefined), "always", ["^core$"])
+        expect(result).toEqual([true, ""])
+    })
+
+    it("uses default \"when\" and \"value\" when not provided", async () => {
+        const result = await ruleFn(createCommit("anyscope"))
+        expect(result).toEqual([true, ""])
+    })
+
+    it("uses default \"value\" when only \"when\" is provided", async () => {
+        const result = await ruleFn(createCommit("anyscope"), "always")
+        expect(result).toEqual([true, ""])
+    })
+
+    it("uses custom message when provided and fails", async () => {
+        const result = await ruleFn(createCommit("utils"), "always", ["^core$", "Custom message"])
+        expect(result).toEqual([false, "Custom message"])
+    })
+})

src/rules/scope-pattern/index.ts

@@ -1,24 +1,24 @@
-import type { Rule } from '@commitlint/types';
-import type { Commit } from 'conventional-commits-parser';
+import type { Rule } from "@commitlint/types"
+import type { Commit } from "conventional-commits-parser"
 
 const rule: Rule = async (
     parsed: Commit,
-    when: 'always' | 'never' = 'always',
-    value: [string, string?] = ['']
+    when: "always" | "never" = "always",
+    value: [string, string?] = [""]
 ) => {
-    const [pattern, message] = value;
+    const [pattern, message] = value
 
-    if (!parsed.scope) return [true, ''];
+    if (!parsed.scope) return [true, ""]
 
-    const regex = new RegExp(pattern);
-    const isMatch = regex.test(parsed.scope);
-    const isNegated = when === 'never';
-    const pass = isNegated ? !isMatch : isMatch;
+    const regex = new RegExp(pattern)
+    const isMatch = regex.test(parsed.scope)
+    const isNegated = when === "never"
+    const pass = isNegated ? !isMatch : isMatch
 
     return [
         pass,
-        pass ? '' : (message || `scope must ${isNegated ? 'not ' : ''}match pattern: ${pattern}`)
-    ];
-};
+        pass ? "" : (message || `scope must ${isNegated ? "not " : ""}match pattern: ${pattern}`)
+    ]
+}
 
 export default rule