@dvukovic/style-guide 0.3.108 → 0.3.110

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@dvukovic/style-guide",
-    "version": "0.3.108",
+    "version": "0.3.110",
     "description": "My own style guide",
     "repository": {
         "type": "git",

package/src/cspell/base.txt

@@ -125,3 +125,15 @@ pageleave
 opensearchservice
 httponly
 unthrown
+supabase
+tslog
+fkey
+msword
+openxmlformats
+officedocument
+wordprocessingml
+presentationml
+spreadsheetml
+pageleave
+autocapture
+opensearchservice

package/src/eslint/plugins/dvukovic.js

@@ -1,4 +1,5 @@
 import { noCommentedOutCode } from "../rules/no-commented-out-code/no-commented-out-code.js"
+import { noT } from "../rules/no-t/no-t.js"
 
 /** @type {import("@eslint/config-helpers").Config} */
 export const dvukovic = {
@@ -6,10 +7,12 @@ export const dvukovic = {
         dvukovic: {
             rules: {
                 "no-commented-out-code": noCommentedOutCode,
+                "no-t": noT,
             },
         },
     },
     rules: {
         "dvukovic/no-commented-out-code": "error",
+        "dvukovic/no-t": "error",
     },
 }

package/src/eslint/rules/no-t/no-t.js

@@ -0,0 +1,43 @@
+export const noT = {
+    create(context) {
+        const [{ prefix = "" } = {}] = context.options
+
+        return {
+            "TSTypeParameter > Identifier[name=/^.$/]"(node) {
+                context.report({
+                    data: { name: node.name },
+                    messageId: "forbidden",
+                    node,
+                })
+            },
+            "TSTypeParameter > Identifier[name=/^.{2,}$/]"(node) {
+                if (prefix && !node.name.startsWith(prefix)) {
+                    context.report({
+                        data: { name: node.name, prefix },
+                        messageId: "prefix",
+                        node,
+                    })
+                }
+            },
+        }
+    },
+    meta: {
+        docs: {
+            description: "Forbids single-character type parameters.",
+        },
+        messages: {
+            forbidden: `Single-character type parameters are forbidden. Choose a more descriptive name for "{{name}}"`,
+            prefix: `Type parameter "{{name}}" does not have prefix "{{prefix}}"`,
+        },
+        schema: [
+            {
+                additionalProperties: false,
+                properties: {
+                    prefix: { type: "string" },
+                },
+                type: "object",
+            },
+        ],
+        type: "problem",
+    },
+}

package/src/eslint/rules/no-t/no-t.test.js

@@ -0,0 +1,85 @@
+import { ESLint } from "eslint"
+import tseslint from "typescript-eslint"
+
+import { dvukovic } from "../../plugins/dvukovic.js"
+
+const eslint = new ESLint({
+    overrideConfig: [
+        {
+            files: ["**/*.ts"],
+            languageOptions: {
+                parser: tseslint.parser,
+            },
+        },
+        dvukovic,
+    ],
+    overrideConfigFile: true,
+})
+
+describe("dvukovic/no-t", () => {
+    test("detects single-character type parameter", async () => {
+        const code = `function foo<T>(arg: T): T { return arg }\n`
+
+        const results = await eslint.lintText(code, { filePath: "test.ts" })
+        const errors = results[0]?.messages.filter((message) => {
+            return message.ruleId === "dvukovic/no-t"
+        })
+
+        expect(errors?.length).toBe(1)
+    })
+
+    test("detects multiple single-character type parameters", async () => {
+        const code = `type Entry<K, V> = { key: K; value: V }\n`
+
+        const results = await eslint.lintText(code, { filePath: "test.ts" })
+        const errors = results[0]?.messages.filter((message) => {
+            return message.ruleId === "dvukovic/no-t"
+        })
+
+        expect(errors?.length).toBe(2)
+    })
+
+    test("allows descriptive type parameters", async () => {
+        const code = `function foo<Element>(arg: Element): Element { return arg }\n`
+
+        const results = await eslint.lintText(code, { filePath: "test.ts" })
+        const errors = results[0]?.messages.filter((message) => {
+            return message.ruleId === "dvukovic/no-t"
+        })
+
+        expect(errors?.length).toBe(0)
+    })
+
+    test("allows descriptive type parameters in type alias", async () => {
+        const code = `type Entry<Key, Value> = { key: Key; value: Value }\n`
+
+        const results = await eslint.lintText(code, { filePath: "test.ts" })
+        const errors = results[0]?.messages.filter((message) => {
+            return message.ruleId === "dvukovic/no-t"
+        })
+
+        expect(errors?.length).toBe(0)
+    })
+
+    test("detects single-character in interface", async () => {
+        const code = `interface Container<T> { value: T }\n`
+
+        const results = await eslint.lintText(code, { filePath: "test.ts" })
+        const errors = results[0]?.messages.filter((message) => {
+            return message.ruleId === "dvukovic/no-t"
+        })
+
+        expect(errors?.length).toBe(1)
+    })
+
+    test("detects single-character in class", async () => {
+        const code = `class Box<T> { constructor(public value: T) {} }\n`
+
+        const results = await eslint.lintText(code, { filePath: "test.ts" })
+        const errors = results[0]?.messages.filter((message) => {
+            return message.ruleId === "dvukovic/no-t"
+        })
+
+        expect(errors?.length).toBe(1)
+    })
+})