feat: add [import-blacklist] converter #277

Author: dimabory

src/rules/converters.ts

@@ -18,6 +18,7 @@ import { convertEofline } from "./converters/eofline";
 import { convertFileNameCasing } from "./converters/file-name-casing";
 import { convertForin } from "./converters/forin";
 import { convertFunctionConstructor } from "./converters/function-constructor";
+import { convertImportBlacklist } from "./converters/import-blacklist";
 import { convertIncrementDecrement } from "./converters/increment-decrement";
 import { convertIndent } from "./converters/indent";
 import { convertInterfaceName } from "./converters/interface-name";
@@ -154,6 +155,7 @@ export const converters = new Map([
     ["file-name-casing", convertFileNameCasing],
     ["forin", convertForin],
     ["function-constructor", convertFunctionConstructor],
+    ["import-blacklist", convertImportBlacklist],
     ["increment-decrement", convertIncrementDecrement],
     ["indent", convertIndent],
     ["interface-name", convertInterfaceName],

src/rules/converters/import-blacklist.ts

@@ -0,0 +1,52 @@
+import { RuleConverter } from "../converter";
+import { RequireAtLeastOne } from "../../utils";
+
+type ESLintOptionPath = {
+    name: string;
+    importNames: string[];
+    message?: string;
+};
+type ESLintSimpleOption = string[];
+type ESLintComplexOption = RequireAtLeastOne<{
+    paths: (string | ESLintOptionPath)[];
+    patterns: string[];
+}>;
+type ESLintOptions = ESLintSimpleOption | ESLintComplexOption;
+
+export const convertImportBlacklist: RuleConverter = tslintRule => {
+    const tslintRules = tslintRule.ruleArguments;
+    let ruleArguments: ESLintOptions = [];
+
+    if (tslintRules.every(isString)) {
+        ruleArguments = tslintRules;
+    } else {
+        ruleArguments = [
+            tslintRules.reduce((rules, rule) => {
+                if (!Array.isArray(rule)) {
+                    const eslintRule = isString(rule)
+                        ? rule
+                        : {
+                              name: Object.keys(rule)[0],
+                              importNames: Object.values(rule)[0] as string[],
+                          };
+                    return { ...rules, paths: [...(rules.paths || []), eslintRule] };
+                } else if (Array.isArray(rule)) {
+                    return { ...rules, patterns: [...(rules.patterns || []), ...rule] };
+                }
+                return rules;
+            }, {} as ESLintComplexOption),
+        ];
+    }
+    return {
+        rules: [
+            {
+                ruleArguments,
+                ruleName: "no-restricted-imports",
+            },
+        ],
+    };
+};
+
+function isString(value: string): boolean {
+    return typeof value === "string";
+}

src/rules/converters/tests/import-blacklist.test.ts

@@ -0,0 +1,67 @@
+import { convertImportBlacklist } from "../import-blacklist";
+
+describe(convertImportBlacklist, () => {
+    test.each([
+        [[], []],
+        [["rxjs"], ["rxjs"]],
+        [
+            ["rxjs", "lodash"],
+            ["rxjs", "lodash"],
+        ],
+        [
+            [".*\\.temp$", ".*\\.tmp$"],
+            [".*\\.temp$", ".*\\.tmp$"],
+        ],
+        [
+            ["moment", "date-fns", ["eslint/*"]],
+            [{ patterns: ["eslint/*"], paths: ["moment", "date-fns"] }],
+        ],
+        [
+            [{ lodash: ["pullAll", "pull"] }],
+            [
+                {
+                    paths: [
+                        {
+                            name: "lodash",
+                            importNames: ["pullAll", "pull"],
+                        },
+                    ],
+                },
+            ],
+        ],
+        [
+            [
+                "rxjs",
+                [".*\\.temp$", ".*\\.tmp$"],
+                { lodash: ["pullAll", "pull"] },
+                { dummy: ["default"] },
+            ],
+            [
+                {
+                    paths: [
+                        "rxjs",
+                        {
+                            name: "lodash",
+                            importNames: ["pullAll", "pull"],
+                        },
+                        {
+                            name: "dummy",
+                            importNames: ["default"],
+                        },
+                    ],
+                    patterns: [".*\\.temp$", ".*\\.tmp$"],
+                },
+            ],
+        ],
+    ] as any[][])("convert %j", (ruleArguments: any[], expected: any[]) => {
+        const result = convertImportBlacklist({ ruleArguments });
+        expect(result).toEqual({
+            rules: [
+                {
+                    ruleArguments: expected,
+                    ruleName: "no-restricted-imports",
+                },
+            ],
+        });
+    });
+});

src/utils.ts

@@ -8,6 +8,11 @@ export type RemoveErrors<Items> = {
 
 export type PromiseValue<T> = T extends Promise<infer R> ? R : never;
 
+export type RequireAtLeastOne<T, Keys extends keyof T = keyof T> = Pick<T, Exclude<keyof T, Keys>> &
+    {
+        [K in Keys]-?: Required<Pick<T, K>> & Partial<Pick<T, Exclude<Keys, K>>>;
+    }[Keys];
+
 export const uniqueFromSources = <T>(...sources: (T | T[] | undefined)[]) => {
     const items: T[] = [];