eslint-plugin-interface-to-type 1.0.0

package/docs/rules/prefer-type-over-interface.md

@@ -0,0 +1,95 @@
+
+# prefer-type-over-interface
+
+This ESLint rule enforces the use of `type` aliases instead of `interface` declarations in TypeScript. It aims to promote consistent and flexible code by leveraging the extended capabilities of `type`, especially in scenarios involving unions, intersections, or complex generic structures.
+
+---
+
+## Motivation
+
+TypeScript provides two primary ways to define structural types: `type` and `interface`. While both serve similar purposes, `type` is often more versatile and is preferred in many projects for the following reasons:
+
+- **Union and Intersection Types:** `type` allows you to create union and intersection types directly, enhancing flexibility.
+- **Generics:** `type` is often more concise and readable when working with generics.
+- **Extensibility:** Using `&` with `type` makes combining and extending types more straightforward.
+- **Consistency:** Favoring `type` over `interface` reduces cognitive overhead when reading code.
+
+---
+
+## Examples
+
+### Incorrect Code
+❌ Using `interface`:
+```typescript
+interface User {
+  id: number;
+  name: string;
+  role: 'admin' | 'user';
+}
+
+interface GenericResponse<T> {
+  data: T;
+  error?: string;
+}
+```
+
+---
+
+### Correct Code
+✅ Using `type`:
+```typescript
+type User = {
+  id: number;
+  name: string;
+  role: 'admin' | 'user';
+};
+
+type GenericResponse<T> = {
+  data: T;
+  error?: string;
+};
+```
+
+---
+
+## Special Cases
+
+1. **Union Types**  
+   `type` is the only way to define union types:
+   ```typescript
+   type Role = 'admin' | 'user' | 'guest';
+   ```
+
+2. **Intersection Types**  
+   Use `&` to combine multiple types:
+   ```typescript
+   type AdminUser = User & { permissions: string[] };
+   ```
+
+3. **Generics**  
+   Generics are cleaner and easier to read with `type`:
+   ```typescript
+   type PaginatedResponse<T> = {
+     items: T[];
+     total: number;
+     currentPage: number;
+   };
+   ```
+
+4. **Extending Types**  
+   `type` allows you to extend multiple structures seamlessly:
+   ```typescript
+   type ExtendedUser = User & { lastLogin: Date };
+   ```
+
+---
+
+## Rule Details
+
+This rule checks all `interface` declarations and suggests converting them to `type`. It preserves the structure and intent of the original `interface` while improving consistency and flexibility in the codebase.
+
+---
+
+## Autofix
+
+This rule supports ESLint's `--fix` option. When enabled, it will automatically convert `interface` declarations into equivalent `type` aliases.

package/index.js

@@ -0,0 +1,5 @@
+module.exports = {
+    rules: {
+        'prefer-type-over-interface': require('./lib/rules/prefer-type-over-interface'),
+    },
+};

package/lib/rules/prefer-type-over-interface.js

@@ -0,0 +1,44 @@
+module.exports = {
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Convert interface to type',
+            category: 'Stylistic Issues',
+            recommended: false
+        },
+        fixable: 'code',
+        schema: []
+    },
+    create(context) {
+        return {
+            TSInterfaceDeclaration(node) {
+                const interfaceName = node.id.name;
+                const sourceCode = context.getSourceCode();
+                const typeParams = node.typeParameters ? sourceCode.getText(node.typeParameters) : '';
+
+                const bodyStart = node.body.range[0];
+                const bodyEnd = node.body.range[1];
+                const bodyContent = sourceCode.getText().slice(bodyStart, bodyEnd);
+
+                const parentTypes = node.extends
+                    ? node.extends.map((extendNode) => sourceCode.getText(extendNode)).join(' & ')
+                    : '';
+
+                let typeText;
+                if (parentTypes) {
+                    typeText = `type ${interfaceName}${typeParams} = ${parentTypes} & ${bodyContent};`;
+                } else {
+                    typeText = `type ${interfaceName}${typeParams} = ${bodyContent};`;
+                }
+
+                context.report({
+                    node,
+                    message: `Interface '${interfaceName}' can be replaced by a type.`,
+                    fix(fixer) {
+                        return fixer.replaceText(node, typeText);
+                    }
+                });
+            }
+        };
+    }
+};

package/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "eslint-plugin-interface-to-type",
+  "version": "1.0.0",
+  "main": "index.js",
+  "scripts": {
+    "test": "mocha tests/**/*.test.js"
+  },
+  "keywords": ["eslint", "typescript", "eslint-plugin", "interface", "type"],
+  "author": "Jan Szotkowski",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/janszotkowski/eslint-plugin-interface-to-type"
+  },
+  "description": "An ESLint plugin to enforce the use of type over interface in TypeScript.",
+  "dependencies": {},
+  "devDependencies": {
+    "@typescript-eslint/eslint-plugin": "^5.62.0",
+    "@typescript-eslint/parser": "^5.62.0",
+    "chai": "^5.1.2",
+    "eslint": "^8.57.1",
+    "eslint-rule-tester": "^2.0.0",
+    "mocha": "^10.8.2"
+  }
+}

package/tests/lib/rules/prefer-type-over-interface.test.js

@@ -0,0 +1,33 @@
+const { RuleTester } = require("eslint");
+const rule = require("../../../lib/rules/prefer-type-over-interface");
+
+const ruleTester = new RuleTester({
+    parser: require.resolve("@typescript-eslint/parser"),
+    parserOptions: {
+        ecmaVersion: 2020,
+        sourceType: "module",
+    },
+});
+
+ruleTester.run("prefer-type-over-interface", rule, {
+    valid: [
+        {
+            code: "type MyType = { field: string; };", // Správný kód
+            filename: "test.ts",
+        },
+    ],
+    invalid: [
+        {
+            code: "interface MyInterface { field: string; }", // Chybný kód
+            filename: "test.ts",
+            errors: [{ message: "Interface 'MyInterface' can be replaced by a type." }],
+            output: "type MyInterface = { field: string; };", // Výstup se středníkem
+        },
+        {
+            code: "interface MyInterface extends Parent { field: string; }",
+            filename: "test.ts",
+            errors: [{ message: "Interface 'MyInterface' can be replaced by a type." }],
+            output: "type MyInterface = Parent & { field: string; };", // Výstup se středníkem
+        },
+    ],
+});