Respect the original TSLint configuration of ban-types

src/rules/converters/ban-types.ts

@@ -1,10 +1,33 @@
 import { RuleConverter } from "../converter";
 
-export const convertBanTypes: RuleConverter = () => {
+export const convertBanTypes: RuleConverter = tslintRule => {
+    type ConvertBanTypeArgument = {
+        message: string;
+    };
+
+    const bannedTypes: Record<string, ConvertBanTypeArgument | null> = {};
+
+    for (const rule of tslintRule.ruleArguments) {
+        if (!Array.isArray(rule)) {
+            break;
+        }
+
+        const [bannedType, message] = rule;
+        if (!bannedType) {
+            break;
+        }
+
+        bannedTypes[bannedType] = message ? { message } : null;
+    }
+
+    const ruleArguments =
+        Object.keys(bannedTypes).length === 0 ? undefined : [{ types: bannedTypes }];
+
     return {
         rules: [
             {
                 ruleName: "@typescript-eslint/ban-types",
+                ...{ ruleArguments },
             },
         ],
     };

src/rules/converters/tests/ban-types.test.ts

@@ -14,4 +14,73 @@ describe(convertBanTypes, () => {
             ],
         });
     });
+
+    test("conversion with arguments", () => {
+        const result = convertBanTypes({
+            ruleArguments: [
+                ["Object", "Use {} instead."],
+                ["String"],
+                ["Number"],
+                ["Boolean", "Use 'boolean' instead."],
+                [], // empty array: this should be ignored
+            ],
+        });
+
+        expect(result).toEqual({
+            rules: [
+                {
+                    ruleName: "@typescript-eslint/ban-types",
+                    ruleArguments: [
+                        {
+                            types: {
+                                Object: {
+                                    message: "Use {} instead.",
+                                },
+                                String: null,
+                                Number: null,
+                                Boolean: {
+                                    message: "Use 'boolean' instead.",
+                                },
+                            },
+                        },
+                    ],
+                },
+            ],
+        });
+    });
+
+    test("conversion with duplicated arguments", () => {
+        const result = convertBanTypes({
+            ruleArguments: [["Object", "Use {} instead."], ["Object"]],
+        });
+
+        expect(result).toEqual({
+            rules: [
+                {
+                    ruleName: "@typescript-eslint/ban-types",
+                    ruleArguments: [
+                        {
+                            types: {
+                                Object: null,
+                            },
+                        },
+                    ],
+                },
+            ],
+        });
+    });
+
+    test("conversion with duplicated arguments", () => {
+        const result = convertBanTypes({
+            ruleArguments: ["!!!this-is-not-array!!!"],
+        });
+
+        expect(result).toEqual({
+            rules: [
+                {
+                    ruleName: "@typescript-eslint/ban-types",
+                },
+            ],
+        });
+    });
 });