feat: converters for ngrx rules

src/converters/lintConfigs/rules/ruleConverters.ts

@@ -64,6 +64,17 @@ import { convertCurly } from "./ruleConverters/curly";
 import { convertCyclomaticComplexity } from "./ruleConverters/cyclomatic-complexity";
 import { convertDeprecation } from "./ruleConverters/deprecation";
 import { convertEofline } from "./ruleConverters/eofline";
+import { convertActionHygiene } from "./ruleConverters/eslint-plugin-ngrx/action-hygiene";
+import { convertAvoidDispatchingMultipleActionsSequentially } from "./ruleConverters/eslint-plugin-ngrx/avoid-dispatching-multiple-actions-sequentially";
+import { convertEffectCreatorAndDecorator } from "./ruleConverters/eslint-plugin-ngrx/effect-creator-and-decorator";
+import { convertNoDispatchInEffects } from "./ruleConverters/eslint-plugin-ngrx/no-dispatch-in-effects";
+import { convertNoEffectDecorator } from "./ruleConverters/eslint-plugin-ngrx/no-effect-decorator";
+import { convertNoEffectsInProviders } from "./ruleConverters/eslint-plugin-ngrx/no-effects-in-providers";
+import { convertNoMultipleActionsInEffects } from "./ruleConverters/eslint-plugin-ngrx/no-multiple-actions-in-effects";
+import { convertNoReducerInKeyNames } from "./ruleConverters/eslint-plugin-ngrx/no-reducer-in-key-names";
+import { convertNoTypedStore } from "./ruleConverters/eslint-plugin-ngrx/no-typed-store";
+import { convertOnReducerExplicitReturnType } from "./ruleConverters/eslint-plugin-ngrx/on-reducer-explicit-return-type";
+import { convertSelectorForSelect } from "./ruleConverters/eslint-plugin-ngrx/selector-for-select";
 import { convertJsxBanProps } from "./ruleConverters/eslint-plugin-react/jsx-ban-props";
 import { convertJsxBooleanValue } from "./ruleConverters/eslint-plugin-react/jsx-boolean-value";
 import { convertJsxCurlySpacing } from "./ruleConverters/eslint-plugin-react/jsx-curly-spacing";
@@ -351,6 +362,21 @@ 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-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/eslint-plugin-ngrx/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/eslint-plugin-ngrx/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/eslint-plugin-ngrx/effect-creator-and-decorator.ts

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

src/converters/lintConfigs/rules/ruleConverters/eslint-plugin-ngrx/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/eslint-plugin-ngrx/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/eslint-plugin-ngrx/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/eslint-plugin-ngrx/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/eslint-plugin-ngrx/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/eslint-plugin-ngrx/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/eslint-plugin-ngrx/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/eslint-plugin-ngrx/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/eslint-plugin-ngrx/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/eslint-plugin-ngrx/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/eslint-plugin-ngrx/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/eslint-plugin-ngrx/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/effect-decorator-and-creator",
+                },
+            ],
+            plugins: ["eslint-plugin-ngrx"],
+        });
+    });
+});

src/converters/lintConfigs/rules/ruleConverters/eslint-plugin-ngrx/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/eslint-plugin-ngrx/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/eslint-plugin-ngrx/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/eslint-plugin-ngrx/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/eslint-plugin-ngrx/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/eslint-plugin-ngrx/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"],
+        });
+    });
+});

src/converters/lintConfigs/rules/ruleConverters/eslint-plugin-ngrx/tests/no-typed-store.test.ts

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