feat: converters for ngrx rules

src/converters/lintConfigs/rules/ruleConverters.ts

@@ -174,6 +174,18 @@ import { convertMochaAvoidOnly } from "./ruleConverters/mocha-avoid-only";
 import { convertNewParens } from "./ruleConverters/new-parens";
 import { convertNewlineBeforeReturn } from "./ruleConverters/newline-before-return";
 import { convertNewlinePerChainedCall } from "./ruleConverters/newline-per-chained-call";
+import { convertActionHygiene } from "./ruleConverters/ngrx-tslint-rules/action-hygiene";
+import { convertAvoidDispatchingMultipleActionsSequentially } from "./ruleConverters/ngrx-tslint-rules/avoid-dispatching-multiple-actions-sequentially";
+import { convertEffectCreatorAndDecorator } from "./ruleConverters/ngrx-tslint-rules/effect-creator-and-decorator";
+import { convertNoDispatchInEffects } from "./ruleConverters/ngrx-tslint-rules/no-dispatch-in-effects";
+import { convertNoDuplicateActionTypes } from "./ruleConverters/ngrx-tslint-rules/no-duplicate-action-types";
+import { convertNoEffectDecorator } from "./ruleConverters/ngrx-tslint-rules/no-effect-decorator";
+import { convertNoEffectsInProviders } from "./ruleConverters/ngrx-tslint-rules/no-effects-in-providers";
+import { convertNoMultipleActionsInEffects } from "./ruleConverters/ngrx-tslint-rules/no-multiple-actions-in-effects";
+import { convertNoReducerInKeyNames } from "./ruleConverters/ngrx-tslint-rules/no-reducer-in-key-names";
+import { convertNoTypedStore } from "./ruleConverters/ngrx-tslint-rules/no-typed-store";
+import { convertOnReducerExplicitReturnType } from "./ruleConverters/ngrx-tslint-rules/on-reducer-explicit-return-type";
+import { convertSelectorForSelect } from "./ruleConverters/ngrx-tslint-rules/selector-for-select";
 import { convertNoAngleBracketTypeAssertion } from "./ruleConverters/no-angle-bracket-type-assertion";
 import { convertNoArg } from "./ruleConverters/no-arg";
 import { convertNoAsyncWithoutAwait } from "./ruleConverters/no-async-without-await";
@@ -377,6 +389,22 @@ export const ruleConverters = new Map([
     ["new-parens", convertNewParens],
     ["newline-before-return", convertNewlineBeforeReturn],
     ["newline-per-chained-call", convertNewlinePerChainedCall],
+    ["ngrx-action-hygiene", convertActionHygiene],
+    [
+        "ngrx-avoid-dispatching-multiple-actions-sequentially",
+        convertAvoidDispatchingMultipleActionsSequentially,
+    ],
+    ["ngrx-effect-creator-and-decorator", convertEffectCreatorAndDecorator],
+    ["ngrx-no-dispatch-in-effects", convertNoDispatchInEffects],
+    ["ngrx-no-duplicate-action-types", convertNoDuplicateActionTypes],
+    ["ngrx-no-effect-decorator", convertNoEffectDecorator],
+    ["ngrx-no-effects-in-providers", convertNoEffectsInProviders],
+    ["ngrx-no-multiple-actions-in-effects", convertNoMultipleActionsInEffects],
+    ["ngrx-no-reducer-in-key-names", convertNoReducerInKeyNames],
+    ["ngrx-no-reducer-in-key-names", convertNoReducerInKeyNames],
+    ["ngrx-no-typed-store", convertNoTypedStore],
+    ["ngrx-on-reducer-explicit-return-type", convertOnReducerExplicitReturnType],
+    ["ngrx-selector-for-select", convertSelectorForSelect],
     ["no-all-duplicated-branches", convertNoAllDuplicatedBranches],
     ["no-alphabetical-sort", convertNoAlphabeticalSort],
     ["no-angle-bracket-type-assertion", convertNoAngleBracketTypeAssertion],

src/converters/lintConfigs/rules/ruleConverters/ngrx-tslint-rules/action-hygiene.ts

@@ -0,0 +1,12 @@
+import { RuleConverter } from "../../ruleConverter";
+
+export const convertActionHygiene: RuleConverter = () => {
+    return {
+        rules: [
+            {
+                ruleName: "ngrx/good-action-hygiene",
+            },
+        ],
+        plugins: ["eslint-plugin-ngrx"],
+    };
+};

src/converters/lintConfigs/rules/ruleConverters/ngrx-tslint-rules/avoid-dispatching-multiple-actions-sequentially.ts

@@ -0,0 +1,12 @@
+import { RuleConverter } from "../../ruleConverter";
+
+export const convertAvoidDispatchingMultipleActionsSequentially: RuleConverter = () => {
+    return {
+        rules: [
+            {
+                ruleName: "ngrx/avoid-dispatching-multiple-actions-sequentially",
+            },
+        ],
+        plugins: ["eslint-plugin-ngrx"],
+    };
+};

src/converters/lintConfigs/rules/ruleConverters/ngrx-tslint-rules/effect-creator-and-decorator.ts

@@ -0,0 +1,12 @@
+import { RuleConverter } from "../../ruleConverter";
+
+export const convertEffectCreatorAndDecorator: RuleConverter = () => {
+    return {
+        rules: [
+            {
+                ruleName: "ngrx/no-effect-decorator-and-creator",
+            },
+        ],
+        plugins: ["eslint-plugin-ngrx"],
+    };
+};

src/converters/lintConfigs/rules/ruleConverters/ngrx-tslint-rules/no-dispatch-in-effects.ts

@@ -0,0 +1,12 @@
+import { RuleConverter } from "../../ruleConverter";
+
+export const convertNoDispatchInEffects: RuleConverter = () => {
+    return {
+        rules: [
+            {
+                ruleName: "ngrx/no-dispatch-in-effects",
+            },
+        ],
+        plugins: ["eslint-plugin-ngrx"],
+    };
+};

src/converters/lintConfigs/rules/ruleConverters/ngrx-tslint-rules/no-duplicate-action-types.ts

@@ -0,0 +1,7 @@
+import { RuleConverter } from "../../ruleConverter";
+
+export const convertNoDuplicateActionTypes: RuleConverter = () => {
+    return {
+        rules: [],
+    };
+};

src/converters/lintConfigs/rules/ruleConverters/ngrx-tslint-rules/no-effect-decorator.ts

@@ -0,0 +1,12 @@
+import { RuleConverter } from "../../ruleConverter";
+
+export const convertNoEffectDecorator: RuleConverter = () => {
+    return {
+        rules: [
+            {
+                ruleName: "ngrx/no-effect-decorator",
+            },
+        ],
+        plugins: ["eslint-plugin-ngrx"],
+    };
+};

src/converters/lintConfigs/rules/ruleConverters/ngrx-tslint-rules/no-effects-in-providers.ts

@@ -0,0 +1,12 @@
+import { RuleConverter } from "../../ruleConverter";
+
+export const convertNoEffectsInProviders: RuleConverter = () => {
+    return {
+        rules: [
+            {
+                ruleName: "ngrx/no-effects-in-providers",
+            },
+        ],
+        plugins: ["eslint-plugin-ngrx"],
+    };
+};

src/converters/lintConfigs/rules/ruleConverters/ngrx-tslint-rules/no-multiple-actions-in-effects.ts

@@ -0,0 +1,12 @@
+import { RuleConverter } from "../../ruleConverter";
+
+export const convertNoMultipleActionsInEffects: RuleConverter = () => {
+    return {
+        rules: [
+            {
+                ruleName: "ngrx/no-multiple-actions-in-effects",
+            },
+        ],
+        plugins: ["eslint-plugin-ngrx"],
+    };
+};

src/converters/lintConfigs/rules/ruleConverters/ngrx-tslint-rules/no-multiple-stores.ts

@@ -0,0 +1,12 @@
+import { RuleConverter } from "../../ruleConverter";
+
+export const convertNoMultipleStores: RuleConverter = () => {
+    return {
+        rules: [
+            {
+                ruleName: "ngrx/no-multiple-global-stores",
+            },
+        ],
+        plugins: ["eslint-plugin-ngrx"],
+    };
+};

src/converters/lintConfigs/rules/ruleConverters/ngrx-tslint-rules/no-reducer-in-key-names.ts

@@ -0,0 +1,12 @@
+import { RuleConverter } from "../../ruleConverter";
+
+export const convertNoReducerInKeyNames: RuleConverter = () => {
+    return {
+        rules: [
+            {
+                ruleName: "ngrx/no-reducer-in-key-names",
+            },
+        ],
+        plugins: ["eslint-plugin-ngrx"],
+    };
+};

src/converters/lintConfigs/rules/ruleConverters/ngrx-tslint-rules/no-typed-store.ts

@@ -0,0 +1,12 @@
+import { RuleConverter } from "../../ruleConverter";
+
+export const convertNoTypedStore: RuleConverter = () => {
+    return {
+        rules: [
+            {
+                ruleName: "ngrx/no-typed-global-store",
+            },
+        ],
+        plugins: ["eslint-plugin-ngrx"],
+    };
+};

src/converters/lintConfigs/rules/ruleConverters/ngrx-tslint-rules/on-reducer-explicit-return-type.ts

@@ -0,0 +1,12 @@
+import { RuleConverter } from "../../ruleConverter";
+
+export const convertOnReducerExplicitReturnType: RuleConverter = () => {
+    return {
+        rules: [
+            {
+                ruleName: "ngrx/on-function-explicit-return-type",
+            },
+        ],
+        plugins: ["eslint-plugin-ngrx"],
+    };
+};

src/converters/lintConfigs/rules/ruleConverters/ngrx-tslint-rules/selector-for-select.ts

@@ -0,0 +1,12 @@
+import { RuleConverter } from "../../ruleConverter";
+
+export const convertSelectorForSelect: RuleConverter = () => {
+    return {
+        rules: [
+            {
+                ruleName: "ngrx/use-selector-in-select",
+            },
+        ],
+        plugins: ["eslint-plugin-ngrx"],
+    };
+};

src/converters/lintConfigs/rules/ruleConverters/ngrx-tslint-rules/tests/action-hygiene.test.ts

@@ -0,0 +1,18 @@
+import { convertActionHygiene } from "../action-hygiene";
+
+describe(convertActionHygiene, () => {
+    test("conversion without arguments", () => {
+        const result = convertActionHygiene({
+            ruleArguments: [],
+        });
+
+        expect(result).toEqual({
+            rules: [
+                {
+                    ruleName: "ngrx/good-action-hygiene",
+                },
+            ],
+            plugins: ["eslint-plugin-ngrx"],
+        });
+    });
+});

src/converters/lintConfigs/rules/ruleConverters/ngrx-tslint-rules/tests/avoid-dispatching-multiple-actions-sequentially.test.ts

@@ -0,0 +1,18 @@
+import { convertAvoidDispatchingMultipleActionsSequentially } from "../avoid-dispatching-multiple-actions-sequentially";
+
+describe(convertAvoidDispatchingMultipleActionsSequentially, () => {
+    test("conversion without arguments", () => {
+        const result = convertAvoidDispatchingMultipleActionsSequentially({
+            ruleArguments: [],
+        });
+
+        expect(result).toEqual({
+            rules: [
+                {
+                    ruleName: "ngrx/avoid-dispatching-multiple-actions-sequentially",
+                },
+            ],
+            plugins: ["eslint-plugin-ngrx"],
+        });
+    });
+});

src/converters/lintConfigs/rules/ruleConverters/ngrx-tslint-rules/tests/effect-creator-and-decorator.test.ts

@@ -0,0 +1,18 @@
+import { convertEffectCreatorAndDecorator } from "../effect-creator-and-decorator";
+
+describe(convertEffectCreatorAndDecorator, () => {
+    test("conversion without arguments", () => {
+        const result = convertEffectCreatorAndDecorator({
+            ruleArguments: [],
+        });
+
+        expect(result).toEqual({
+            rules: [
+                {
+                    ruleName: "ngrx/no-effect-decorator-and-creator",
+                },
+            ],
+            plugins: ["eslint-plugin-ngrx"],
+        });
+    });
+});

src/converters/lintConfigs/rules/ruleConverters/ngrx-tslint-rules/tests/no-dispatch-in-effects.test.ts

@@ -0,0 +1,18 @@
+import { convertNoDispatchInEffects } from "../no-dispatch-in-effects";
+
+describe(convertNoDispatchInEffects, () => {
+    test("conversion without arguments", () => {
+        const result = convertNoDispatchInEffects({
+            ruleArguments: [],
+        });
+
+        expect(result).toEqual({
+            rules: [
+                {
+                    ruleName: "ngrx/no-dispatch-in-effects",
+                },
+            ],
+            plugins: ["eslint-plugin-ngrx"],
+        });
+    });
+});

src/converters/lintConfigs/rules/ruleConverters/ngrx-tslint-rules/tests/no-duplicate-action-types.test.ts

@@ -0,0 +1,13 @@
+import { convertNoDuplicateActionTypes } from "../no-duplicate-action-types";
+
+describe(convertNoDuplicateActionTypes, () => {
+    test("conversion without arguments", () => {
+        const result = convertNoDuplicateActionTypes({
+            ruleArguments: [],
+        });
+
+        expect(result).toEqual({
+            rules: [],
+        });
+    });
+});

src/converters/lintConfigs/rules/ruleConverters/ngrx-tslint-rules/tests/no-effect-decorator.test.ts

@@ -0,0 +1,18 @@
+import { convertNoEffectDecorator } from "../no-effect-decorator";
+
+describe(convertNoEffectDecorator, () => {
+    test("conversion without arguments", () => {
+        const result = convertNoEffectDecorator({
+            ruleArguments: [],
+        });
+
+        expect(result).toEqual({
+            rules: [
+                {
+                    ruleName: "ngrx/no-effect-decorator",
+                },
+            ],
+            plugins: ["eslint-plugin-ngrx"],
+        });
+    });
+});

src/converters/lintConfigs/rules/ruleConverters/ngrx-tslint-rules/tests/no-effects-in-providers.test.ts

@@ -0,0 +1,18 @@
+import { convertNoEffectsInProviders } from "../no-effects-in-providers";
+
+describe(convertNoEffectsInProviders, () => {
+    test("conversion without arguments", () => {
+        const result = convertNoEffectsInProviders({
+            ruleArguments: [],
+        });
+
+        expect(result).toEqual({
+            rules: [
+                {
+                    ruleName: "ngrx/no-effects-in-providers",
+                },
+            ],
+            plugins: ["eslint-plugin-ngrx"],
+        });
+    });
+});

src/converters/lintConfigs/rules/ruleConverters/ngrx-tslint-rules/tests/no-multiple-actions-in-effects.test.ts

@@ -0,0 +1,18 @@
+import { convertNoMultipleActionsInEffects } from "../no-multiple-actions-in-effects";
+
+describe(convertNoMultipleActionsInEffects, () => {
+    test("conversion without arguments", () => {
+        const result = convertNoMultipleActionsInEffects({
+            ruleArguments: [],
+        });
+
+        expect(result).toEqual({
+            rules: [
+                {
+                    ruleName: "ngrx/no-multiple-actions-in-effects",
+                },
+            ],
+            plugins: ["eslint-plugin-ngrx"],
+        });
+    });
+});

src/converters/lintConfigs/rules/ruleConverters/ngrx-tslint-rules/tests/no-multiple-stores.test.ts

@@ -0,0 +1,18 @@
+import { convertNoMultipleStores } from "../no-multiple-stores";
+
+describe(convertNoMultipleStores, () => {
+    test("conversion without arguments", () => {
+        const result = convertNoMultipleStores({
+            ruleArguments: [],
+        });
+
+        expect(result).toEqual({
+            rules: [
+                {
+                    ruleName: "ngrx/no-multiple-global-stores",
+                },
+            ],
+            plugins: ["eslint-plugin-ngrx"],
+        });
+    });
+});

src/converters/lintConfigs/rules/ruleConverters/ngrx-tslint-rules/tests/no-reducer-in-key-names.test.ts

@@ -0,0 +1,18 @@
+import { convertNoReducerInKeyNames } from "../no-reducer-in-key-names";
+
+describe(convertNoReducerInKeyNames, () => {
+    test("conversion without arguments", () => {
+        const result = convertNoReducerInKeyNames({
+            ruleArguments: [],
+        });
+
+        expect(result).toEqual({
+            rules: [
+                {
+                    ruleName: "ngrx/no-reducer-in-key-names",
+                },
+            ],
+            plugins: ["eslint-plugin-ngrx"],
+        });
+    });
+});