Added missing no-implicit-dependencies converter (#230)

* Add no-implicit-dependencies converter

* Add whitelist support

* Add plugin import and fix tsc issues

Author: melbarch

src/rules/converters.ts

@@ -53,6 +53,7 @@ import { convertNoExplicitAny } from "./converters/no-explicit-any";
 import { convertNoFloatingPromises } from "./converters/no-floating-promises";
 import { convertNoForIn } from "./converters/no-for-in";
 import { convertNoForInArray } from "./converters/no-for-in-array";
+import { convertNoImplicitDependencies } from "./converters/no-implicit-dependencies";
 import { convertNoInferrableTypes } from "./converters/no-inferrable-types";
 import { convertNoInternalModule } from "./converters/no-internal-module";
 import { convertNoInvalidRegexp } from "./converters/no-invalid-regexp";
@@ -181,6 +182,7 @@ export const converters = new Map([
     ["no-eval", convertNoEval],
     ["no-floating-promises", convertNoFloatingPromises],
     ["no-for-in-array", convertNoForInArray],
+    ["no-implicit-dependencies", convertNoImplicitDependencies],
     ["no-for-in", convertNoForIn],
     ["no-inferrable-types", convertNoInferrableTypes],
     ["no-internal-module", convertNoInternalModule],

src/rules/converters/no-implicit-dependencies.ts

@@ -0,0 +1,30 @@
+import { RuleConverter } from "../converter";
+
+export const convertNoImplicitDependencies: RuleConverter = tslintRule => {
+    const ruleArgs: {
+        [eslintOption in "devDependencies" | "optionalDependencies"]?: boolean
+    }[] = [];
+    const notices: string[] = [];
+
+    tslintRule.ruleArguments.forEach(element => {
+        if (element === "dev") {
+            ruleArgs.push({ devDependencies: false });
+        } else if (element === "optional") {
+            ruleArgs.push({ optionalDependencies: false });
+        } else {
+            notices.push("ESLint does not support whitelisting modules");
+        }
+    });
+
+    return {
+        rules: [
+            {
+                ruleName: "import/no-extraneous-dependencies",
+                ...(ruleArgs.length > 0 && { ruleArguments: ruleArgs }),
+                ...(notices.length > 0 && { notices }),
+            },
+        ],
+
+        plugins: ["import"],
+    };
+};

src/rules/converters/tests/no-implicit-dependencies.test.ts

@@ -0,0 +1,82 @@
+import { convertNoImplicitDependencies } from "../no-implicit-dependencies";
+
+describe(convertNoImplicitDependencies, () => {
+    test("conversion without arguments", () => {
+        const result = convertNoImplicitDependencies({
+            ruleArguments: [],
+        });
+
+        expect(result).toEqual({
+            rules: [
+                {
+                    ruleName: "import/no-extraneous-dependencies",
+                },
+            ],
+            plugins: ["import"],
+        });
+    });
+
+    test("conversion with dev argument", () => {
+        const result = convertNoImplicitDependencies({
+            ruleArguments: ["dev"],
+        });
+
+        expect(result).toEqual({
+            rules: [
+                {
+                    ruleArguments: [{ devDependencies: false }],
+                    ruleName: "import/no-extraneous-dependencies",
+                },
+            ],
+            plugins: ["import"],
+        });
+    });
+
+    test("conversion with optional argument", () => {
+        const result = convertNoImplicitDependencies({
+            ruleArguments: ["optional"],
+        });
+
+        expect(result).toEqual({
+            rules: [
+                {
+                    ruleArguments: [{ optionalDependencies: false }],
+                    ruleName: "import/no-extraneous-dependencies",
+                },
+            ],
+            plugins: ["import"],
+        });
+    });
+
+    test("conversion with both dev and optional argument", () => {
+        const result = convertNoImplicitDependencies({
+            ruleArguments: ["dev", "optional"],
+        });
+
+        expect(result).toEqual({
+            rules: [
+                {
+                    ruleArguments: [{ devDependencies: false }, { optionalDependencies: false }],
+                    ruleName: "import/no-extraneous-dependencies",
+                },
+            ],
+            plugins: ["import"],
+        });
+    });
+
+    test("conversion with whitelisted folders argument", () => {
+        const result = convertNoImplicitDependencies({
+            ruleArguments: [["src", "app"]],
+        });
+
+        expect(result).toEqual({
+            rules: [
+                {
+                    notices: ["ESLint does not support whitelisting modules"],
+                    ruleName: "import/no-extraneous-dependencies",
+                },
+            ],
+            plugins: ["import"],
+        });
+    });
+});