@dvukovic/style-guide 0.3.107 → 0.3.109

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@dvukovic/style-guide",
-    "version": "0.3.107",
+    "version": "0.3.109",
     "description": "My own style guide",
     "repository": {
         "type": "git",
@@ -31,12 +31,12 @@
     "dependencies": {
         "@eslint-community/eslint-plugin-eslint-comments": "4.5.0",
         "@eslint/compat": "^2.0.0",
-        "@next/eslint-plugin-next": "16.0.10",
+        "@next/eslint-plugin-next": "16.1.0",
         "@prettier/plugin-xml": "3.4.2",
         "@rimac-technology/eslint-plugin": "1.5.0",
         "@stylistic/eslint-plugin": "5.6.1",
-        "@typescript-eslint/parser": "8.49.0",
-        "@vitest/eslint-plugin": "1.5.2",
+        "@typescript-eslint/parser": "8.50.0",
+        "@vitest/eslint-plugin": "1.5.4",
         "eslint-plugin-es-x": "9.3.0",
         "eslint-plugin-import-x": "4.16.1",
         "eslint-plugin-jest": "29.4.0",
@@ -51,12 +51,12 @@
         "eslint-plugin-sonarjs": "3.0.5",
         "eslint-plugin-sort-destructure-keys": "2.0.0",
         "eslint-plugin-sort-keys-fix": "1.1.2",
-        "eslint-plugin-storybook": "10.1.8",
+        "eslint-plugin-storybook": "10.1.10",
         "eslint-plugin-typescript-sort-keys": "3.3.0",
         "eslint-plugin-unicorn": "62.0.0",
         "eslint-plugin-unused-imports": "4.3.0",
         "globals": "16.5.0",
-        "prettier-plugin-embed": "0.5.0",
+        "prettier-plugin-embed": "0.5.1",
         "prettier-plugin-jsdoc": "1.8.0",
         "prettier-plugin-packagejson": "2.5.20",
         "prettier-plugin-prisma": "5.0.0",
@@ -66,10 +66,10 @@
         "prettier-plugin-toml": "2.0.6",
         "stylelint-no-unused-selectors": "1.0.40",
         "stylelint-order": "7.0.0",
-        "typescript-eslint": "8.49.0"
+        "typescript-eslint": "8.50.0"
     },
     "devDependencies": {
-        "@storybook/react": "10.1.8",
+        "@storybook/react": "10.1.10",
         "@types/eslint": "9.6.1",
         "@types/jest": "30.0.0",
         "@types/node": "24.10.4",
@@ -81,10 +81,10 @@
         "prettier": "3.7.4",
         "react": "19.2.3",
         "release-it": "19.1.0",
-        "storybook": "^10.1.8",
+        "storybook": "^10.1.10",
         "stylelint": "16.26.1",
         "typescript": "5.9.3",
-        "vitest": "^4.0.15"
+        "vitest": "^4.0.16"
     },
     "peerDependencies": {
         "cspell": "9",

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/plugins/typescript-eslint.js

@@ -134,6 +134,7 @@ export const typescriptEslint = {
         ],
         "@typescript-eslint/no-use-before-define": "error",
         "@typescript-eslint/no-useless-constructor": "error",
+        "@typescript-eslint/no-useless-default-assignment": "error",
         "@typescript-eslint/no-useless-empty-export": "error",
         "@typescript-eslint/no-wrapper-object-types": "error",
         "@typescript-eslint/non-nullable-type-assertion-style": "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)
+    })
+})