src/context/extensions/helpers/processConfig.js

Summary

Maintainability
C
7 hrs
Test Coverage

Function validateConfig has 31 lines of code (exceeds 25 allowed). Consider refactoring.
Open

export function validateConfig(name, extension, state) {
    const extensionConfigPaths = getKeys(extension.config, true);
    const extensionMetaPaths = getKeys(extension.meta);
    const stateConfigPaths = getKeys(state.config, true);
    const stateMetaPaths = getKeys(state.meta);
Severity: Minor
Found in src/context/extensions/helpers/processConfig.js - About 1 hr to fix

    Function validateMetaStructure has 26 lines of code (exceeds 25 allowed). Consider refactoring.
    Open

    function validateMetaStructure(name, intersections, stateConfigPaths, extensionMeta, stateMeta) {
        intersections.forEach((intersect) => {
            const wasGroup = getGroup(stateConfigPaths, intersect);
    
            if (!wasGroup || get(extensionMeta, `${intersect}.__meta`)) {
    Severity: Minor
    Found in src/context/extensions/helpers/processConfig.js - About 1 hr to fix

      Function validateConfigurationStructure has 6 arguments (exceeds 4 allowed). Consider refactoring.
      Open

          name, intersections, extensionConfigPaths, stateConfigPaths, extensionMeta, stateMeta
      Severity: Minor
      Found in src/context/extensions/helpers/processConfig.js - About 45 mins to fix

        Consider simplifying this complex logical expression.
        Open

                if (!wasGroup || get(extensionMeta, `${intersect}.__meta`)) {
                    const stateExtensions = get(stateMeta, intersect).__extensions || [];
                    const extensionExtensions = get(extensionMeta, intersect).__extensions || [];
        
                    // If it is a group the override info will be on __meta and if not it will be directly on the object
        Severity: Major
        Found in src/context/extensions/helpers/processConfig.js - About 40 mins to fix

          Function getKeys has 5 arguments (exceeds 4 allowed). Consider refactoring.
          Open

          function getKeys(obj = {}, flag = false, oldPath = '', allKeys = [], allGroups = []) {
          Severity: Minor
          Found in src/context/extensions/helpers/processConfig.js - About 35 mins to fix

            Function validateMetaStructure has 5 arguments (exceeds 4 allowed). Consider refactoring.
            Open

            function validateMetaStructure(name, intersections, stateConfigPaths, extensionMeta, stateMeta) {
            Severity: Minor
            Found in src/context/extensions/helpers/processConfig.js - About 35 mins to fix

              Function updateStateMeta has 5 arguments (exceeds 4 allowed). Consider refactoring.
              Open

              function updateStateMeta(name, state, extensionConfigPaths, extensionMetaPaths, stateConfigPaths) {
              Severity: Minor
              Found in src/context/extensions/helpers/processConfig.js - About 35 mins to fix

                Missing trailing comma.
                Open

                        )

                require or disallow trailing commas (comma-dangle)

                Trailing commas in object literals are valid according to the ECMAScript 5 (and ECMAScript 3!) spec. However, IE8 (when not in IE8 document mode) and below will throw an error when it encounters trailing commas in JavaScript.

                var foo = {
                    bar: "baz",
                    qux: "quux",
                };

                Trailing commas simplify adding and removing items to objects and arrays, since only the lines you are modifying must be touched. Another argument in favor of trailing commas is that it improves the clarity of diffs when an item is added or removed from an object or array:

                Less clear:

                var foo = {
                -    bar: "baz",
                -    qux: "quux"
                +    bar: "baz"
                 };

                More clear:

                var foo = {
                     bar: "baz",
                -    qux: "quux",
                 };

                Rule Details

                This rule enforces consistent use of trailing commas in object and array literals.

                Options

                This rule has a string option or an object option:

                {
                    "comma-dangle": ["error", "never"],
                    // or
                    "comma-dangle": ["error", {
                        "arrays": "never",
                        "objects": "never",
                        "imports": "never",
                        "exports": "never",
                        "functions": "ignore",
                    }]
                }
                • "never" (default) disallows trailing commas
                • "always" requires trailing commas
                • "always-multiline" requires trailing commas when the last element or property is in a different line than the closing ] or } and disallows trailing commas when the last element or property is on the same line as the closing ] or }
                • "only-multiline" allows (but does not require) trailing commas when the last element or property is in a different line than the closing ] or } and disallows trailing commas when the last element or property is on the same line as the closing ] or }

                Trailing commas in function declarations and function calls are valid syntax since ECMAScript 2017; however, the string option does not check these situations for backwards compatibility.

                You can also use an object option to configure this rule for each type of syntax. Each of the following options can be set to "never", "always", "always-multiline", "only-multiline", or "ignore". The default for each option is "never" unless otherwise specified.

                • arrays is for array literals and array patterns of destructuring. (e.g. let [a,] = [1,];)
                • objects is for object literals and object patterns of destructuring. (e.g. let {a,} = {a: 1};)
                • imports is for import declarations of ES Modules. (e.g. import {a,} from "foo";)
                • exports is for export declarations of ES Modules. (e.g. export {a,};)
                • functions is for function declarations and function calls. (e.g. (function(a,){ })(b,);)
                  functions is set to "ignore" by default for consistency with the string option.

                never

                Examples of incorrect code for this rule with the default "never" option:

                /*eslint comma-dangle: ["error", "never"]*/
                
                var foo = {
                    bar: "baz",
                    qux: "quux",
                };
                
                var arr = [1,2,];
                
                foo({
                  bar: "baz",
                  qux: "quux",
                });

                Examples of correct code for this rule with the default "never" option:

                /*eslint comma-dangle: ["error", "never"]*/
                
                var foo = {
                    bar: "baz",
                    qux: "quux"
                };
                
                var arr = [1,2];
                
                foo({
                  bar: "baz",
                  qux: "quux"
                });

                always

                Examples of incorrect code for this rule with the "always" option:

                /*eslint comma-dangle: ["error", "always"]*/
                
                var foo = {
                    bar: "baz",
                    qux: "quux"
                };
                
                var arr = [1,2];
                
                foo({
                  bar: "baz",
                  qux: "quux"
                });

                Examples of correct code for this rule with the "always" option:

                /*eslint comma-dangle: ["error", "always"]*/
                
                var foo = {
                    bar: "baz",
                    qux: "quux",
                };
                
                var arr = [1,2,];
                
                foo({
                  bar: "baz",
                  qux: "quux",
                });

                always-multiline

                Examples of incorrect code for this rule with the "always-multiline" option:

                /*eslint comma-dangle: ["error", "always-multiline"]*/
                
                var foo = {
                    bar: "baz",
                    qux: "quux"
                };
                
                var foo = { bar: "baz", qux: "quux", };
                
                var arr = [1,2,];
                
                var arr = [1,
                    2,];
                
                var arr = [
                    1,
                    2
                ];
                
                foo({
                  bar: "baz",
                  qux: "quux"
                });

                Examples of correct code for this rule with the "always-multiline" option:

                /*eslint comma-dangle: ["error", "always-multiline"]*/
                
                var foo = {
                    bar: "baz",
                    qux: "quux",
                };
                
                var foo = {bar: "baz", qux: "quux"};
                var arr = [1,2];
                
                var arr = [1,
                    2];
                
                var arr = [
                    1,
                    2,
                ];
                
                foo({
                  bar: "baz",
                  qux: "quux",
                });

                only-multiline

                Examples of incorrect code for this rule with the "only-multiline" option:

                /*eslint comma-dangle: ["error", "only-multiline"]*/
                
                var foo = { bar: "baz", qux: "quux", };
                
                var arr = [1,2,];
                
                var arr = [1,
                    2,];

                Examples of correct code for this rule with the "only-multiline" option:

                /*eslint comma-dangle: ["error", "only-multiline"]*/
                
                var foo = {
                    bar: "baz",
                    qux: "quux",
                };
                
                var foo = {
                    bar: "baz",
                    qux: "quux"
                };
                
                var foo = {bar: "baz", qux: "quux"};
                var arr = [1,2];
                
                var arr = [1,
                    2];
                
                var arr = [
                    1,
                    2,
                ];
                
                var arr = [
                    1,
                    2
                ];
                
                foo({
                  bar: "baz",
                  qux: "quux",
                });
                
                foo({
                  bar: "baz",
                  qux: "quux"
                });

                functions

                Examples of incorrect code for this rule with the {"functions": "never"} option:

                /*eslint comma-dangle: ["error", {"functions": "never"}]*/
                
                function foo(a, b,) {
                }
                
                foo(a, b,);
                new foo(a, b,);

                Examples of correct code for this rule with the {"functions": "never"} option:

                /*eslint comma-dangle: ["error", {"functions": "never"}]*/
                
                function foo(a, b) {
                }
                
                foo(a, b);
                new foo(a, b);

                Examples of incorrect code for this rule with the {"functions": "always"} option:

                /*eslint comma-dangle: ["error", {"functions": "always"}]*/
                
                function foo(a, b) {
                }
                
                foo(a, b);
                new foo(a, b);

                Examples of correct code for this rule with the {"functions": "always"} option:

                /*eslint comma-dangle: ["error", {"functions": "always"}]*/
                
                function foo(a, b,) {
                }
                
                foo(a, b,);
                new foo(a, b,);

                When Not To Use It

                You can turn this rule off if you are not concerned with dangling commas. Source: http://eslint.org/docs/rules/

                Missing trailing comma.
                Open

                            stateConfigPaths.paths

                require or disallow trailing commas (comma-dangle)

                Trailing commas in object literals are valid according to the ECMAScript 5 (and ECMAScript 3!) spec. However, IE8 (when not in IE8 document mode) and below will throw an error when it encounters trailing commas in JavaScript.

                var foo = {
                    bar: "baz",
                    qux: "quux",
                };

                Trailing commas simplify adding and removing items to objects and arrays, since only the lines you are modifying must be touched. Another argument in favor of trailing commas is that it improves the clarity of diffs when an item is added or removed from an object or array:

                Less clear:

                var foo = {
                -    bar: "baz",
                -    qux: "quux"
                +    bar: "baz"
                 };

                More clear:

                var foo = {
                     bar: "baz",
                -    qux: "quux",
                 };

                Rule Details

                This rule enforces consistent use of trailing commas in object and array literals.

                Options

                This rule has a string option or an object option:

                {
                    "comma-dangle": ["error", "never"],
                    // or
                    "comma-dangle": ["error", {
                        "arrays": "never",
                        "objects": "never",
                        "imports": "never",
                        "exports": "never",
                        "functions": "ignore",
                    }]
                }
                • "never" (default) disallows trailing commas
                • "always" requires trailing commas
                • "always-multiline" requires trailing commas when the last element or property is in a different line than the closing ] or } and disallows trailing commas when the last element or property is on the same line as the closing ] or }
                • "only-multiline" allows (but does not require) trailing commas when the last element or property is in a different line than the closing ] or } and disallows trailing commas when the last element or property is on the same line as the closing ] or }

                Trailing commas in function declarations and function calls are valid syntax since ECMAScript 2017; however, the string option does not check these situations for backwards compatibility.

                You can also use an object option to configure this rule for each type of syntax. Each of the following options can be set to "never", "always", "always-multiline", "only-multiline", or "ignore". The default for each option is "never" unless otherwise specified.

                • arrays is for array literals and array patterns of destructuring. (e.g. let [a,] = [1,];)
                • objects is for object literals and object patterns of destructuring. (e.g. let {a,} = {a: 1};)
                • imports is for import declarations of ES Modules. (e.g. import {a,} from "foo";)
                • exports is for export declarations of ES Modules. (e.g. export {a,};)
                • functions is for function declarations and function calls. (e.g. (function(a,){ })(b,);)
                  functions is set to "ignore" by default for consistency with the string option.

                never

                Examples of incorrect code for this rule with the default "never" option:

                /*eslint comma-dangle: ["error", "never"]*/
                
                var foo = {
                    bar: "baz",
                    qux: "quux",
                };
                
                var arr = [1,2,];
                
                foo({
                  bar: "baz",
                  qux: "quux",
                });

                Examples of correct code for this rule with the default "never" option:

                /*eslint comma-dangle: ["error", "never"]*/
                
                var foo = {
                    bar: "baz",
                    qux: "quux"
                };
                
                var arr = [1,2];
                
                foo({
                  bar: "baz",
                  qux: "quux"
                });

                always

                Examples of incorrect code for this rule with the "always" option:

                /*eslint comma-dangle: ["error", "always"]*/
                
                var foo = {
                    bar: "baz",
                    qux: "quux"
                };
                
                var arr = [1,2];
                
                foo({
                  bar: "baz",
                  qux: "quux"
                });

                Examples of correct code for this rule with the "always" option:

                /*eslint comma-dangle: ["error", "always"]*/
                
                var foo = {
                    bar: "baz",
                    qux: "quux",
                };
                
                var arr = [1,2,];
                
                foo({
                  bar: "baz",
                  qux: "quux",
                });

                always-multiline

                Examples of incorrect code for this rule with the "always-multiline" option:

                /*eslint comma-dangle: ["error", "always-multiline"]*/
                
                var foo = {
                    bar: "baz",
                    qux: "quux"
                };
                
                var foo = { bar: "baz", qux: "quux", };
                
                var arr = [1,2,];
                
                var arr = [1,
                    2,];
                
                var arr = [
                    1,
                    2
                ];
                
                foo({
                  bar: "baz",
                  qux: "quux"
                });

                Examples of correct code for this rule with the "always-multiline" option:

                /*eslint comma-dangle: ["error", "always-multiline"]*/
                
                var foo = {
                    bar: "baz",
                    qux: "quux",
                };
                
                var foo = {bar: "baz", qux: "quux"};
                var arr = [1,2];
                
                var arr = [1,
                    2];
                
                var arr = [
                    1,
                    2,
                ];
                
                foo({
                  bar: "baz",
                  qux: "quux",
                });

                only-multiline

                Examples of incorrect code for this rule with the "only-multiline" option:

                /*eslint comma-dangle: ["error", "only-multiline"]*/
                
                var foo = { bar: "baz", qux: "quux", };
                
                var arr = [1,2,];
                
                var arr = [1,
                    2,];

                Examples of correct code for this rule with the "only-multiline" option:

                /*eslint comma-dangle: ["error", "only-multiline"]*/
                
                var foo = {
                    bar: "baz",
                    qux: "quux",
                };
                
                var foo = {
                    bar: "baz",
                    qux: "quux"
                };
                
                var foo = {bar: "baz", qux: "quux"};
                var arr = [1,2];
                
                var arr = [1,
                    2];
                
                var arr = [
                    1,
                    2,
                ];
                
                var arr = [
                    1,
                    2
                ];
                
                foo({
                  bar: "baz",
                  qux: "quux",
                });
                
                foo({
                  bar: "baz",
                  qux: "quux"
                });

                functions

                Examples of incorrect code for this rule with the {"functions": "never"} option:

                /*eslint comma-dangle: ["error", {"functions": "never"}]*/
                
                function foo(a, b,) {
                }
                
                foo(a, b,);
                new foo(a, b,);

                Examples of correct code for this rule with the {"functions": "never"} option:

                /*eslint comma-dangle: ["error", {"functions": "never"}]*/
                
                function foo(a, b) {
                }
                
                foo(a, b);
                new foo(a, b);

                Examples of incorrect code for this rule with the {"functions": "always"} option:

                /*eslint comma-dangle: ["error", {"functions": "always"}]*/
                
                function foo(a, b) {
                }
                
                foo(a, b);
                new foo(a, b);

                Examples of correct code for this rule with the {"functions": "always"} option:

                /*eslint comma-dangle: ["error", {"functions": "always"}]*/
                
                function foo(a, b,) {
                }
                
                foo(a, b,);
                new foo(a, b,);

                When Not To Use It

                You can turn this rule off if you are not concerned with dangling commas. Source: http://eslint.org/docs/rules/

                Missing trailing comma.
                Open

                                    `Contact the developer of ${underline(name)} for help.`

                require or disallow trailing commas (comma-dangle)

                Trailing commas in object literals are valid according to the ECMAScript 5 (and ECMAScript 3!) spec. However, IE8 (when not in IE8 document mode) and below will throw an error when it encounters trailing commas in JavaScript.

                var foo = {
                    bar: "baz",
                    qux: "quux",
                };

                Trailing commas simplify adding and removing items to objects and arrays, since only the lines you are modifying must be touched. Another argument in favor of trailing commas is that it improves the clarity of diffs when an item is added or removed from an object or array:

                Less clear:

                var foo = {
                -    bar: "baz",
                -    qux: "quux"
                +    bar: "baz"
                 };

                More clear:

                var foo = {
                     bar: "baz",
                -    qux: "quux",
                 };

                Rule Details

                This rule enforces consistent use of trailing commas in object and array literals.

                Options

                This rule has a string option or an object option:

                {
                    "comma-dangle": ["error", "never"],
                    // or
                    "comma-dangle": ["error", {
                        "arrays": "never",
                        "objects": "never",
                        "imports": "never",
                        "exports": "never",
                        "functions": "ignore",
                    }]
                }
                • "never" (default) disallows trailing commas
                • "always" requires trailing commas
                • "always-multiline" requires trailing commas when the last element or property is in a different line than the closing ] or } and disallows trailing commas when the last element or property is on the same line as the closing ] or }
                • "only-multiline" allows (but does not require) trailing commas when the last element or property is in a different line than the closing ] or } and disallows trailing commas when the last element or property is on the same line as the closing ] or }

                Trailing commas in function declarations and function calls are valid syntax since ECMAScript 2017; however, the string option does not check these situations for backwards compatibility.

                You can also use an object option to configure this rule for each type of syntax. Each of the following options can be set to "never", "always", "always-multiline", "only-multiline", or "ignore". The default for each option is "never" unless otherwise specified.

                • arrays is for array literals and array patterns of destructuring. (e.g. let [a,] = [1,];)
                • objects is for object literals and object patterns of destructuring. (e.g. let {a,} = {a: 1};)
                • imports is for import declarations of ES Modules. (e.g. import {a,} from "foo";)
                • exports is for export declarations of ES Modules. (e.g. export {a,};)
                • functions is for function declarations and function calls. (e.g. (function(a,){ })(b,);)
                  functions is set to "ignore" by default for consistency with the string option.

                never

                Examples of incorrect code for this rule with the default "never" option:

                /*eslint comma-dangle: ["error", "never"]*/
                
                var foo = {
                    bar: "baz",
                    qux: "quux",
                };
                
                var arr = [1,2,];
                
                foo({
                  bar: "baz",
                  qux: "quux",
                });

                Examples of correct code for this rule with the default "never" option:

                /*eslint comma-dangle: ["error", "never"]*/
                
                var foo = {
                    bar: "baz",
                    qux: "quux"
                };
                
                var arr = [1,2];
                
                foo({
                  bar: "baz",
                  qux: "quux"
                });

                always

                Examples of incorrect code for this rule with the "always" option:

                /*eslint comma-dangle: ["error", "always"]*/
                
                var foo = {
                    bar: "baz",
                    qux: "quux"
                };
                
                var arr = [1,2];
                
                foo({
                  bar: "baz",
                  qux: "quux"
                });

                Examples of correct code for this rule with the "always" option:

                /*eslint comma-dangle: ["error", "always"]*/
                
                var foo = {
                    bar: "baz",
                    qux: "quux",
                };
                
                var arr = [1,2,];
                
                foo({
                  bar: "baz",
                  qux: "quux",
                });

                always-multiline

                Examples of incorrect code for this rule with the "always-multiline" option:

                /*eslint comma-dangle: ["error", "always-multiline"]*/
                
                var foo = {
                    bar: "baz",
                    qux: "quux"
                };
                
                var foo = { bar: "baz", qux: "quux", };
                
                var arr = [1,2,];
                
                var arr = [1,
                    2,];
                
                var arr = [
                    1,
                    2
                ];
                
                foo({
                  bar: "baz",
                  qux: "quux"
                });

                Examples of correct code for this rule with the "always-multiline" option:

                /*eslint comma-dangle: ["error", "always-multiline"]*/
                
                var foo = {
                    bar: "baz",
                    qux: "quux",
                };
                
                var foo = {bar: "baz", qux: "quux"};
                var arr = [1,2];
                
                var arr = [1,
                    2];
                
                var arr = [
                    1,
                    2,
                ];
                
                foo({
                  bar: "baz",
                  qux: "quux",
                });

                only-multiline

                Examples of incorrect code for this rule with the "only-multiline" option:

                /*eslint comma-dangle: ["error", "only-multiline"]*/
                
                var foo = { bar: "baz", qux: "quux", };
                
                var arr = [1,2,];
                
                var arr = [1,
                    2,];

                Examples of correct code for this rule with the "only-multiline" option:

                /*eslint comma-dangle: ["error", "only-multiline"]*/
                
                var foo = {
                    bar: "baz",
                    qux: "quux",
                };
                
                var foo = {
                    bar: "baz",
                    qux: "quux"
                };
                
                var foo = {bar: "baz", qux: "quux"};
                var arr = [1,2];
                
                var arr = [1,
                    2];
                
                var arr = [
                    1,
                    2,
                ];
                
                var arr = [
                    1,
                    2
                ];
                
                foo({
                  bar: "baz",
                  qux: "quux",
                });
                
                foo({
                  bar: "baz",
                  qux: "quux"
                });

                functions

                Examples of incorrect code for this rule with the {"functions": "never"} option:

                /*eslint comma-dangle: ["error", {"functions": "never"}]*/
                
                function foo(a, b,) {
                }
                
                foo(a, b,);
                new foo(a, b,);

                Examples of correct code for this rule with the {"functions": "never"} option:

                /*eslint comma-dangle: ["error", {"functions": "never"}]*/
                
                function foo(a, b) {
                }
                
                foo(a, b);
                new foo(a, b);

                Examples of incorrect code for this rule with the {"functions": "always"} option:

                /*eslint comma-dangle: ["error", {"functions": "always"}]*/
                
                function foo(a, b) {
                }
                
                foo(a, b);
                new foo(a, b);

                Examples of correct code for this rule with the {"functions": "always"} option:

                /*eslint comma-dangle: ["error", {"functions": "always"}]*/
                
                function foo(a, b,) {
                }
                
                foo(a, b,);
                new foo(a, b,);

                When Not To Use It

                You can turn this rule off if you are not concerned with dangling commas. Source: http://eslint.org/docs/rules/

                Missing trailing comma.
                Open

                            stateMetaPaths.paths

                require or disallow trailing commas (comma-dangle)

                Trailing commas in object literals are valid according to the ECMAScript 5 (and ECMAScript 3!) spec. However, IE8 (when not in IE8 document mode) and below will throw an error when it encounters trailing commas in JavaScript.

                var foo = {
                    bar: "baz",
                    qux: "quux",
                };

                Trailing commas simplify adding and removing items to objects and arrays, since only the lines you are modifying must be touched. Another argument in favor of trailing commas is that it improves the clarity of diffs when an item is added or removed from an object or array:

                Less clear:

                var foo = {
                -    bar: "baz",
                -    qux: "quux"
                +    bar: "baz"
                 };

                More clear:

                var foo = {
                     bar: "baz",
                -    qux: "quux",
                 };

                Rule Details

                This rule enforces consistent use of trailing commas in object and array literals.

                Options

                This rule has a string option or an object option:

                {
                    "comma-dangle": ["error", "never"],
                    // or
                    "comma-dangle": ["error", {
                        "arrays": "never",
                        "objects": "never",
                        "imports": "never",
                        "exports": "never",
                        "functions": "ignore",
                    }]
                }
                • "never" (default) disallows trailing commas
                • "always" requires trailing commas
                • "always-multiline" requires trailing commas when the last element or property is in a different line than the closing ] or } and disallows trailing commas when the last element or property is on the same line as the closing ] or }
                • "only-multiline" allows (but does not require) trailing commas when the last element or property is in a different line than the closing ] or } and disallows trailing commas when the last element or property is on the same line as the closing ] or }

                Trailing commas in function declarations and function calls are valid syntax since ECMAScript 2017; however, the string option does not check these situations for backwards compatibility.

                You can also use an object option to configure this rule for each type of syntax. Each of the following options can be set to "never", "always", "always-multiline", "only-multiline", or "ignore". The default for each option is "never" unless otherwise specified.

                • arrays is for array literals and array patterns of destructuring. (e.g. let [a,] = [1,];)
                • objects is for object literals and object patterns of destructuring. (e.g. let {a,} = {a: 1};)
                • imports is for import declarations of ES Modules. (e.g. import {a,} from "foo";)
                • exports is for export declarations of ES Modules. (e.g. export {a,};)
                • functions is for function declarations and function calls. (e.g. (function(a,){ })(b,);)
                  functions is set to "ignore" by default for consistency with the string option.

                never

                Examples of incorrect code for this rule with the default "never" option:

                /*eslint comma-dangle: ["error", "never"]*/
                
                var foo = {
                    bar: "baz",
                    qux: "quux",
                };
                
                var arr = [1,2,];
                
                foo({
                  bar: "baz",
                  qux: "quux",
                });

                Examples of correct code for this rule with the default "never" option:

                /*eslint comma-dangle: ["error", "never"]*/
                
                var foo = {
                    bar: "baz",
                    qux: "quux"
                };
                
                var arr = [1,2];
                
                foo({
                  bar: "baz",
                  qux: "quux"
                });

                always

                Examples of incorrect code for this rule with the "always" option:

                /*eslint comma-dangle: ["error", "always"]*/
                
                var foo = {
                    bar: "baz",
                    qux: "quux"
                };
                
                var arr = [1,2];
                
                foo({
                  bar: "baz",
                  qux: "quux"
                });

                Examples of correct code for this rule with the "always" option:

                /*eslint comma-dangle: ["error", "always"]*/
                
                var foo = {
                    bar: "baz",
                    qux: "quux",
                };
                
                var arr = [1,2,];
                
                foo({
                  bar: "baz",
                  qux: "quux",
                });

                always-multiline

                Examples of incorrect code for this rule with the "always-multiline" option:

                /*eslint comma-dangle: ["error", "always-multiline"]*/
                
                var foo = {
                    bar: "baz",
                    qux: "quux"
                };
                
                var foo = { bar: "baz", qux: "quux", };
                
                var arr = [1,2,];
                
                var arr = [1,
                    2,];
                
                var arr = [
                    1,
                    2
                ];
                
                foo({
                  bar: "baz",
                  qux: "quux"
                });

                Examples of correct code for this rule with the "always-multiline" option:

                /*eslint comma-dangle: ["error", "always-multiline"]*/
                
                var foo = {
                    bar: "baz",
                    qux: "quux",
                };
                
                var foo = {bar: "baz", qux: "quux"};
                var arr = [1,2];
                
                var arr = [1,
                    2];
                
                var arr = [
                    1,
                    2,
                ];
                
                foo({
                  bar: "baz",
                  qux: "quux",
                });

                only-multiline

                Examples of incorrect code for this rule with the "only-multiline" option:

                /*eslint comma-dangle: ["error", "only-multiline"]*/
                
                var foo = { bar: "baz", qux: "quux", };
                
                var arr = [1,2,];
                
                var arr = [1,
                    2,];

                Examples of correct code for this rule with the "only-multiline" option:

                /*eslint comma-dangle: ["error", "only-multiline"]*/
                
                var foo = {
                    bar: "baz",
                    qux: "quux",
                };
                
                var foo = {
                    bar: "baz",
                    qux: "quux"
                };
                
                var foo = {bar: "baz", qux: "quux"};
                var arr = [1,2];
                
                var arr = [1,
                    2];
                
                var arr = [
                    1,
                    2,
                ];
                
                var arr = [
                    1,
                    2
                ];
                
                foo({
                  bar: "baz",
                  qux: "quux",
                });
                
                foo({
                  bar: "baz",
                  qux: "quux"
                });

                functions

                Examples of incorrect code for this rule with the {"functions": "never"} option:

                /*eslint comma-dangle: ["error", {"functions": "never"}]*/
                
                function foo(a, b,) {
                }
                
                foo(a, b,);
                new foo(a, b,);

                Examples of correct code for this rule with the {"functions": "never"} option:

                /*eslint comma-dangle: ["error", {"functions": "never"}]*/
                
                function foo(a, b) {
                }
                
                foo(a, b);
                new foo(a, b);

                Examples of incorrect code for this rule with the {"functions": "always"} option:

                /*eslint comma-dangle: ["error", {"functions": "always"}]*/
                
                function foo(a, b) {
                }
                
                foo(a, b);
                new foo(a, b);

                Examples of correct code for this rule with the {"functions": "always"} option:

                /*eslint comma-dangle: ["error", {"functions": "always"}]*/
                
                function foo(a, b,) {
                }
                
                foo(a, b,);
                new foo(a, b,);

                When Not To Use It

                You can turn this rule off if you are not concerned with dangling commas. Source: http://eslint.org/docs/rules/

                Missing trailing comma.
                Open

                            })

                require or disallow trailing commas (comma-dangle)

                Trailing commas in object literals are valid according to the ECMAScript 5 (and ECMAScript 3!) spec. However, IE8 (when not in IE8 document mode) and below will throw an error when it encounters trailing commas in JavaScript.

                var foo = {
                    bar: "baz",
                    qux: "quux",
                };

                Trailing commas simplify adding and removing items to objects and arrays, since only the lines you are modifying must be touched. Another argument in favor of trailing commas is that it improves the clarity of diffs when an item is added or removed from an object or array:

                Less clear:

                var foo = {
                -    bar: "baz",
                -    qux: "quux"
                +    bar: "baz"
                 };

                More clear:

                var foo = {
                     bar: "baz",
                -    qux: "quux",
                 };

                Rule Details

                This rule enforces consistent use of trailing commas in object and array literals.

                Options

                This rule has a string option or an object option:

                {
                    "comma-dangle": ["error", "never"],
                    // or
                    "comma-dangle": ["error", {
                        "arrays": "never",
                        "objects": "never",
                        "imports": "never",
                        "exports": "never",
                        "functions": "ignore",
                    }]
                }
                • "never" (default) disallows trailing commas
                • "always" requires trailing commas
                • "always-multiline" requires trailing commas when the last element or property is in a different line than the closing ] or } and disallows trailing commas when the last element or property is on the same line as the closing ] or }
                • "only-multiline" allows (but does not require) trailing commas when the last element or property is in a different line than the closing ] or } and disallows trailing commas when the last element or property is on the same line as the closing ] or }

                Trailing commas in function declarations and function calls are valid syntax since ECMAScript 2017; however, the string option does not check these situations for backwards compatibility.

                You can also use an object option to configure this rule for each type of syntax. Each of the following options can be set to "never", "always", "always-multiline", "only-multiline", or "ignore". The default for each option is "never" unless otherwise specified.

                • arrays is for array literals and array patterns of destructuring. (e.g. let [a,] = [1,];)
                • objects is for object literals and object patterns of destructuring. (e.g. let {a,} = {a: 1};)
                • imports is for import declarations of ES Modules. (e.g. import {a,} from "foo";)
                • exports is for export declarations of ES Modules. (e.g. export {a,};)
                • functions is for function declarations and function calls. (e.g. (function(a,){ })(b,);)
                  functions is set to "ignore" by default for consistency with the string option.

                never

                Examples of incorrect code for this rule with the default "never" option:

                /*eslint comma-dangle: ["error", "never"]*/
                
                var foo = {
                    bar: "baz",
                    qux: "quux",
                };
                
                var arr = [1,2,];
                
                foo({
                  bar: "baz",
                  qux: "quux",
                });

                Examples of correct code for this rule with the default "never" option:

                /*eslint comma-dangle: ["error", "never"]*/
                
                var foo = {
                    bar: "baz",
                    qux: "quux"
                };
                
                var arr = [1,2];
                
                foo({
                  bar: "baz",
                  qux: "quux"
                });

                always

                Examples of incorrect code for this rule with the "always" option:

                /*eslint comma-dangle: ["error", "always"]*/
                
                var foo = {
                    bar: "baz",
                    qux: "quux"
                };
                
                var arr = [1,2];
                
                foo({
                  bar: "baz",
                  qux: "quux"
                });

                Examples of correct code for this rule with the "always" option:

                /*eslint comma-dangle: ["error", "always"]*/
                
                var foo = {
                    bar: "baz",
                    qux: "quux",
                };
                
                var arr = [1,2,];
                
                foo({
                  bar: "baz",
                  qux: "quux",
                });

                always-multiline

                Examples of incorrect code for this rule with the "always-multiline" option:

                /*eslint comma-dangle: ["error", "always-multiline"]*/
                
                var foo = {
                    bar: "baz",
                    qux: "quux"
                };
                
                var foo = { bar: "baz", qux: "quux", };
                
                var arr = [1,2,];
                
                var arr = [1,
                    2,];
                
                var arr = [
                    1,
                    2
                ];
                
                foo({
                  bar: "baz",
                  qux: "quux"
                });

                Examples of correct code for this rule with the "always-multiline" option:

                /*eslint comma-dangle: ["error", "always-multiline"]*/
                
                var foo = {
                    bar: "baz",
                    qux: "quux",
                };
                
                var foo = {bar: "baz", qux: "quux"};
                var arr = [1,2];
                
                var arr = [1,
                    2];
                
                var arr = [
                    1,
                    2,
                ];
                
                foo({
                  bar: "baz",
                  qux: "quux",
                });

                only-multiline

                Examples of incorrect code for this rule with the "only-multiline" option:

                /*eslint comma-dangle: ["error", "only-multiline"]*/
                
                var foo = { bar: "baz", qux: "quux", };
                
                var arr = [1,2,];
                
                var arr = [1,
                    2,];

                Examples of correct code for this rule with the "only-multiline" option:

                /*eslint comma-dangle: ["error", "only-multiline"]*/
                
                var foo = {
                    bar: "baz",
                    qux: "quux",
                };
                
                var foo = {
                    bar: "baz",
                    qux: "quux"
                };
                
                var foo = {bar: "baz", qux: "quux"};
                var arr = [1,2];
                
                var arr = [1,
                    2];
                
                var arr = [
                    1,
                    2,
                ];
                
                var arr = [
                    1,
                    2
                ];
                
                foo({
                  bar: "baz",
                  qux: "quux",
                });
                
                foo({
                  bar: "baz",
                  qux: "quux"
                });

                functions

                Examples of incorrect code for this rule with the {"functions": "never"} option:

                /*eslint comma-dangle: ["error", {"functions": "never"}]*/
                
                function foo(a, b,) {
                }
                
                foo(a, b,);
                new foo(a, b,);

                Examples of correct code for this rule with the {"functions": "never"} option:

                /*eslint comma-dangle: ["error", {"functions": "never"}]*/
                
                function foo(a, b) {
                }
                
                foo(a, b);
                new foo(a, b);

                Examples of incorrect code for this rule with the {"functions": "always"} option:

                /*eslint comma-dangle: ["error", {"functions": "always"}]*/
                
                function foo(a, b) {
                }
                
                foo(a, b);
                new foo(a, b);

                Examples of correct code for this rule with the {"functions": "always"} option:

                /*eslint comma-dangle: ["error", {"functions": "always"}]*/
                
                function foo(a, b,) {
                }
                
                foo(a, b,);
                new foo(a, b,);

                When Not To Use It

                You can turn this rule off if you are not concerned with dangling commas. Source: http://eslint.org/docs/rules/

                Missing trailing comma.
                Open

                        state.meta

                require or disallow trailing commas (comma-dangle)

                Trailing commas in object literals are valid according to the ECMAScript 5 (and ECMAScript 3!) spec. However, IE8 (when not in IE8 document mode) and below will throw an error when it encounters trailing commas in JavaScript.

                var foo = {
                    bar: "baz",
                    qux: "quux",
                };

                Trailing commas simplify adding and removing items to objects and arrays, since only the lines you are modifying must be touched. Another argument in favor of trailing commas is that it improves the clarity of diffs when an item is added or removed from an object or array:

                Less clear:

                var foo = {
                -    bar: "baz",
                -    qux: "quux"
                +    bar: "baz"
                 };

                More clear:

                var foo = {
                     bar: "baz",
                -    qux: "quux",
                 };

                Rule Details

                This rule enforces consistent use of trailing commas in object and array literals.

                Options

                This rule has a string option or an object option:

                {
                    "comma-dangle": ["error", "never"],
                    // or
                    "comma-dangle": ["error", {
                        "arrays": "never",
                        "objects": "never",
                        "imports": "never",
                        "exports": "never",
                        "functions": "ignore",
                    }]
                }
                • "never" (default) disallows trailing commas
                • "always" requires trailing commas
                • "always-multiline" requires trailing commas when the last element or property is in a different line than the closing ] or } and disallows trailing commas when the last element or property is on the same line as the closing ] or }
                • "only-multiline" allows (but does not require) trailing commas when the last element or property is in a different line than the closing ] or } and disallows trailing commas when the last element or property is on the same line as the closing ] or }

                Trailing commas in function declarations and function calls are valid syntax since ECMAScript 2017; however, the string option does not check these situations for backwards compatibility.

                You can also use an object option to configure this rule for each type of syntax. Each of the following options can be set to "never", "always", "always-multiline", "only-multiline", or "ignore". The default for each option is "never" unless otherwise specified.

                • arrays is for array literals and array patterns of destructuring. (e.g. let [a,] = [1,];)
                • objects is for object literals and object patterns of destructuring. (e.g. let {a,} = {a: 1};)
                • imports is for import declarations of ES Modules. (e.g. import {a,} from "foo";)
                • exports is for export declarations of ES Modules. (e.g. export {a,};)
                • functions is for function declarations and function calls. (e.g. (function(a,){ })(b,);)
                  functions is set to "ignore" by default for consistency with the string option.

                never

                Examples of incorrect code for this rule with the default "never" option:

                /*eslint comma-dangle: ["error", "never"]*/
                
                var foo = {
                    bar: "baz",
                    qux: "quux",
                };
                
                var arr = [1,2,];
                
                foo({
                  bar: "baz",
                  qux: "quux",
                });

                Examples of correct code for this rule with the default "never" option:

                /*eslint comma-dangle: ["error", "never"]*/
                
                var foo = {
                    bar: "baz",
                    qux: "quux"
                };
                
                var arr = [1,2];
                
                foo({
                  bar: "baz",
                  qux: "quux"
                });

                always

                Examples of incorrect code for this rule with the "always" option:

                /*eslint comma-dangle: ["error", "always"]*/
                
                var foo = {
                    bar: "baz",
                    qux: "quux"
                };
                
                var arr = [1,2];
                
                foo({
                  bar: "baz",
                  qux: "quux"
                });

                Examples of correct code for this rule with the "always" option:

                /*eslint comma-dangle: ["error", "always"]*/
                
                var foo = {
                    bar: "baz",
                    qux: "quux",
                };
                
                var arr = [1,2,];
                
                foo({
                  bar: "baz",
                  qux: "quux",
                });

                always-multiline

                Examples of incorrect code for this rule with the "always-multiline" option:

                /*eslint comma-dangle: ["error", "always-multiline"]*/
                
                var foo = {
                    bar: "baz",
                    qux: "quux"
                };
                
                var foo = { bar: "baz", qux: "quux", };
                
                var arr = [1,2,];
                
                var arr = [1,
                    2,];
                
                var arr = [
                    1,
                    2
                ];
                
                foo({
                  bar: "baz",
                  qux: "quux"
                });

                Examples of correct code for this rule with the "always-multiline" option:

                /*eslint comma-dangle: ["error", "always-multiline"]*/
                
                var foo = {
                    bar: "baz",
                    qux: "quux",
                };
                
                var foo = {bar: "baz", qux: "quux"};
                var arr = [1,2];
                
                var arr = [1,
                    2];
                
                var arr = [
                    1,
                    2,
                ];
                
                foo({
                  bar: "baz",
                  qux: "quux",
                });

                only-multiline

                Examples of incorrect code for this rule with the "only-multiline" option:

                /*eslint comma-dangle: ["error", "only-multiline"]*/
                
                var foo = { bar: "baz", qux: "quux", };
                
                var arr = [1,2,];
                
                var arr = [1,
                    2,];

                Examples of correct code for this rule with the "only-multiline" option:

                /*eslint comma-dangle: ["error", "only-multiline"]*/
                
                var foo = {
                    bar: "baz",
                    qux: "quux",
                };
                
                var foo = {
                    bar: "baz",
                    qux: "quux"
                };
                
                var foo = {bar: "baz", qux: "quux"};
                var arr = [1,2];
                
                var arr = [1,
                    2];
                
                var arr = [
                    1,
                    2,
                ];
                
                var arr = [
                    1,
                    2
                ];
                
                foo({
                  bar: "baz",
                  qux: "quux",
                });
                
                foo({
                  bar: "baz",
                  qux: "quux"
                });

                functions

                Examples of incorrect code for this rule with the {"functions": "never"} option:

                /*eslint comma-dangle: ["error", {"functions": "never"}]*/
                
                function foo(a, b,) {
                }
                
                foo(a, b,);
                new foo(a, b,);

                Examples of correct code for this rule with the {"functions": "never"} option:

                /*eslint comma-dangle: ["error", {"functions": "never"}]*/
                
                function foo(a, b) {
                }
                
                foo(a, b);
                new foo(a, b);

                Examples of incorrect code for this rule with the {"functions": "always"} option:

                /*eslint comma-dangle: ["error", {"functions": "always"}]*/
                
                function foo(a, b) {
                }
                
                foo(a, b);
                new foo(a, b);

                Examples of correct code for this rule with the {"functions": "always"} option:

                /*eslint comma-dangle: ["error", {"functions": "always"}]*/
                
                function foo(a, b,) {
                }
                
                foo(a, b,);
                new foo(a, b,);

                When Not To Use It

                You can turn this rule off if you are not concerned with dangling commas. Source: http://eslint.org/docs/rules/

                Missing trailing comma.
                Open

                        stateConfigPaths

                require or disallow trailing commas (comma-dangle)

                Trailing commas in object literals are valid according to the ECMAScript 5 (and ECMAScript 3!) spec. However, IE8 (when not in IE8 document mode) and below will throw an error when it encounters trailing commas in JavaScript.

                var foo = {
                    bar: "baz",
                    qux: "quux",
                };

                Trailing commas simplify adding and removing items to objects and arrays, since only the lines you are modifying must be touched. Another argument in favor of trailing commas is that it improves the clarity of diffs when an item is added or removed from an object or array:

                Less clear:

                var foo = {
                -    bar: "baz",
                -    qux: "quux"
                +    bar: "baz"
                 };

                More clear:

                var foo = {
                     bar: "baz",
                -    qux: "quux",
                 };

                Rule Details

                This rule enforces consistent use of trailing commas in object and array literals.

                Options

                This rule has a string option or an object option:

                {
                    "comma-dangle": ["error", "never"],
                    // or
                    "comma-dangle": ["error", {
                        "arrays": "never",
                        "objects": "never",
                        "imports": "never",
                        "exports": "never",
                        "functions": "ignore",
                    }]
                }
                • "never" (default) disallows trailing commas
                • "always" requires trailing commas
                • "always-multiline" requires trailing commas when the last element or property is in a different line than the closing ] or } and disallows trailing commas when the last element or property is on the same line as the closing ] or }
                • "only-multiline" allows (but does not require) trailing commas when the last element or property is in a different line than the closing ] or } and disallows trailing commas when the last element or property is on the same line as the closing ] or }

                Trailing commas in function declarations and function calls are valid syntax since ECMAScript 2017; however, the string option does not check these situations for backwards compatibility.

                You can also use an object option to configure this rule for each type of syntax. Each of the following options can be set to "never", "always", "always-multiline", "only-multiline", or "ignore". The default for each option is "never" unless otherwise specified.

                • arrays is for array literals and array patterns of destructuring. (e.g. let [a,] = [1,];)
                • objects is for object literals and object patterns of destructuring. (e.g. let {a,} = {a: 1};)
                • imports is for import declarations of ES Modules. (e.g. import {a,} from "foo";)
                • exports is for export declarations of ES Modules. (e.g. export {a,};)
                • functions is for function declarations and function calls. (e.g. (function(a,){ })(b,);)
                  functions is set to "ignore" by default for consistency with the string option.

                never

                Examples of incorrect code for this rule with the default "never" option:

                /*eslint comma-dangle: ["error", "never"]*/
                
                var foo = {
                    bar: "baz",
                    qux: "quux",
                };
                
                var arr = [1,2,];
                
                foo({
                  bar: "baz",
                  qux: "quux",
                });

                Examples of correct code for this rule with the default "never" option:

                /*eslint comma-dangle: ["error", "never"]*/
                
                var foo = {
                    bar: "baz",
                    qux: "quux"
                };
                
                var arr = [1,2];
                
                foo({
                  bar: "baz",
                  qux: "quux"
                });

                always

                Examples of incorrect code for this rule with the "always" option:

                /*eslint comma-dangle: ["error", "always"]*/
                
                var foo = {
                    bar: "baz",
                    qux: "quux"
                };
                
                var arr = [1,2];
                
                foo({
                  bar: "baz",
                  qux: "quux"
                });

                Examples of correct code for this rule with the "always" option:

                /*eslint comma-dangle: ["error", "always"]*/
                
                var foo = {
                    bar: "baz",
                    qux: "quux",
                };
                
                var arr = [1,2,];
                
                foo({
                  bar: "baz",
                  qux: "quux",
                });

                always-multiline

                Examples of incorrect code for this rule with the "always-multiline" option:

                /*eslint comma-dangle: ["error", "always-multiline"]*/
                
                var foo = {
                    bar: "baz",
                    qux: "quux"
                };
                
                var foo = { bar: "baz", qux: "quux", };
                
                var arr = [1,2,];
                
                var arr = [1,
                    2,];
                
                var arr = [
                    1,
                    2
                ];
                
                foo({
                  bar: "baz",
                  qux: "quux"
                });

                Examples of correct code for this rule with the "always-multiline" option:

                /*eslint comma-dangle: ["error", "always-multiline"]*/
                
                var foo = {
                    bar: "baz",
                    qux: "quux",
                };
                
                var foo = {bar: "baz", qux: "quux"};
                var arr = [1,2];
                
                var arr = [1,
                    2];
                
                var arr = [
                    1,
                    2,
                ];
                
                foo({
                  bar: "baz",
                  qux: "quux",
                });

                only-multiline

                Examples of incorrect code for this rule with the "only-multiline" option:

                /*eslint comma-dangle: ["error", "only-multiline"]*/
                
                var foo = { bar: "baz", qux: "quux", };
                
                var arr = [1,2,];
                
                var arr = [1,
                    2,];

                Examples of correct code for this rule with the "only-multiline" option:

                /*eslint comma-dangle: ["error", "only-multiline"]*/
                
                var foo = {
                    bar: "baz",
                    qux: "quux",
                };
                
                var foo = {
                    bar: "baz",
                    qux: "quux"
                };
                
                var foo = {bar: "baz", qux: "quux"};
                var arr = [1,2];
                
                var arr = [1,
                    2];
                
                var arr = [
                    1,
                    2,
                ];
                
                var arr = [
                    1,
                    2
                ];
                
                foo({
                  bar: "baz",
                  qux: "quux",
                });
                
                foo({
                  bar: "baz",
                  qux: "quux"
                });

                functions

                Examples of incorrect code for this rule with the {"functions": "never"} option:

                /*eslint comma-dangle: ["error", {"functions": "never"}]*/
                
                function foo(a, b,) {
                }
                
                foo(a, b,);
                new foo(a, b,);

                Examples of correct code for this rule with the {"functions": "never"} option:

                /*eslint comma-dangle: ["error", {"functions": "never"}]*/
                
                function foo(a, b) {
                }
                
                foo(a, b);
                new foo(a, b);

                Examples of incorrect code for this rule with the {"functions": "always"} option:

                /*eslint comma-dangle: ["error", {"functions": "always"}]*/
                
                function foo(a, b) {
                }
                
                foo(a, b);
                new foo(a, b);

                Examples of correct code for this rule with the {"functions": "always"} option:

                /*eslint comma-dangle: ["error", {"functions": "always"}]*/
                
                function foo(a, b,) {
                }
                
                foo(a, b,);
                new foo(a, b,);

                When Not To Use It

                You can turn this rule off if you are not concerned with dangling commas. Source: http://eslint.org/docs/rules/

                Missing trailing comma.
                Open

                    name, intersections, extensionConfigPaths, stateConfigPaths, extensionMeta, stateMeta

                require or disallow trailing commas (comma-dangle)

                Trailing commas in object literals are valid according to the ECMAScript 5 (and ECMAScript 3!) spec. However, IE8 (when not in IE8 document mode) and below will throw an error when it encounters trailing commas in JavaScript.

                var foo = {
                    bar: "baz",
                    qux: "quux",
                };

                Trailing commas simplify adding and removing items to objects and arrays, since only the lines you are modifying must be touched. Another argument in favor of trailing commas is that it improves the clarity of diffs when an item is added or removed from an object or array:

                Less clear:

                var foo = {
                -    bar: "baz",
                -    qux: "quux"
                +    bar: "baz"
                 };

                More clear:

                var foo = {
                     bar: "baz",
                -    qux: "quux",
                 };

                Rule Details

                This rule enforces consistent use of trailing commas in object and array literals.

                Options

                This rule has a string option or an object option:

                {
                    "comma-dangle": ["error", "never"],
                    // or
                    "comma-dangle": ["error", {
                        "arrays": "never",
                        "objects": "never",
                        "imports": "never",
                        "exports": "never",
                        "functions": "ignore",
                    }]
                }
                • "never" (default) disallows trailing commas
                • "always" requires trailing commas
                • "always-multiline" requires trailing commas when the last element or property is in a different line than the closing ] or } and disallows trailing commas when the last element or property is on the same line as the closing ] or }
                • "only-multiline" allows (but does not require) trailing commas when the last element or property is in a different line than the closing ] or } and disallows trailing commas when the last element or property is on the same line as the closing ] or }

                Trailing commas in function declarations and function calls are valid syntax since ECMAScript 2017; however, the string option does not check these situations for backwards compatibility.

                You can also use an object option to configure this rule for each type of syntax. Each of the following options can be set to "never", "always", "always-multiline", "only-multiline", or "ignore". The default for each option is "never" unless otherwise specified.

                • arrays is for array literals and array patterns of destructuring. (e.g. let [a,] = [1,];)
                • objects is for object literals and object patterns of destructuring. (e.g. let {a,} = {a: 1};)
                • imports is for import declarations of ES Modules. (e.g. import {a,} from "foo";)
                • exports is for export declarations of ES Modules. (e.g. export {a,};)
                • functions is for function declarations and function calls. (e.g. (function(a,){ })(b,);)
                  functions is set to "ignore" by default for consistency with the string option.

                never

                Examples of incorrect code for this rule with the default "never" option:

                /*eslint comma-dangle: ["error", "never"]*/
                
                var foo = {
                    bar: "baz",
                    qux: "quux",
                };
                
                var arr = [1,2,];
                
                foo({
                  bar: "baz",
                  qux: "quux",
                });

                Examples of correct code for this rule with the default "never" option:

                /*eslint comma-dangle: ["error", "never"]*/
                
                var foo = {
                    bar: "baz",
                    qux: "quux"
                };
                
                var arr = [1,2];
                
                foo({
                  bar: "baz",
                  qux: "quux"
                });

                always

                Examples of incorrect code for this rule with the "always" option:

                /*eslint comma-dangle: ["error", "always"]*/
                
                var foo = {
                    bar: "baz",
                    qux: "quux"
                };
                
                var arr = [1,2];
                
                foo({
                  bar: "baz",
                  qux: "quux"
                });

                Examples of correct code for this rule with the "always" option:

                /*eslint comma-dangle: ["error", "always"]*/
                
                var foo = {
                    bar: "baz",
                    qux: "quux",
                };
                
                var arr = [1,2,];
                
                foo({
                  bar: "baz",
                  qux: "quux",
                });

                always-multiline

                Examples of incorrect code for this rule with the "always-multiline" option:

                /*eslint comma-dangle: ["error", "always-multiline"]*/
                
                var foo = {
                    bar: "baz",
                    qux: "quux"
                };
                
                var foo = { bar: "baz", qux: "quux", };
                
                var arr = [1,2,];
                
                var arr = [1,
                    2,];
                
                var arr = [
                    1,
                    2
                ];
                
                foo({
                  bar: "baz",
                  qux: "quux"
                });

                Examples of correct code for this rule with the "always-multiline" option:

                /*eslint comma-dangle: ["error", "always-multiline"]*/
                
                var foo = {
                    bar: "baz",
                    qux: "quux",
                };
                
                var foo = {bar: "baz", qux: "quux"};
                var arr = [1,2];
                
                var arr = [1,
                    2];
                
                var arr = [
                    1,
                    2,
                ];
                
                foo({
                  bar: "baz",
                  qux: "quux",
                });

                only-multiline

                Examples of incorrect code for this rule with the "only-multiline" option:

                /*eslint comma-dangle: ["error", "only-multiline"]*/
                
                var foo = { bar: "baz", qux: "quux", };
                
                var arr = [1,2,];
                
                var arr = [1,
                    2,];

                Examples of correct code for this rule with the "only-multiline" option:

                /*eslint comma-dangle: ["error", "only-multiline"]*/
                
                var foo = {
                    bar: "baz",
                    qux: "quux",
                };
                
                var foo = {
                    bar: "baz",
                    qux: "quux"
                };
                
                var foo = {bar: "baz", qux: "quux"};
                var arr = [1,2];
                
                var arr = [1,
                    2];
                
                var arr = [
                    1,
                    2,
                ];
                
                var arr = [
                    1,
                    2
                ];
                
                foo({
                  bar: "baz",
                  qux: "quux",
                });
                
                foo({
                  bar: "baz",
                  qux: "quux"
                });

                functions

                Examples of incorrect code for this rule with the {"functions": "never"} option:

                /*eslint comma-dangle: ["error", {"functions": "never"}]*/
                
                function foo(a, b,) {
                }
                
                foo(a, b,);
                new foo(a, b,);

                Examples of correct code for this rule with the {"functions": "never"} option:

                /*eslint comma-dangle: ["error", {"functions": "never"}]*/
                
                function foo(a, b) {
                }
                
                foo(a, b);
                new foo(a, b);

                Examples of incorrect code for this rule with the {"functions": "always"} option:

                /*eslint comma-dangle: ["error", {"functions": "always"}]*/
                
                function foo(a, b) {
                }
                
                foo(a, b);
                new foo(a, b);

                Examples of correct code for this rule with the {"functions": "always"} option:

                /*eslint comma-dangle: ["error", {"functions": "always"}]*/
                
                function foo(a, b,) {
                }
                
                foo(a, b,);
                new foo(a, b,);

                When Not To Use It

                You can turn this rule off if you are not concerned with dangling commas. Source: http://eslint.org/docs/rules/

                Missing trailing comma.
                Open

                                    `Contact the developer of ${underline(name)} for help.`

                require or disallow trailing commas (comma-dangle)

                Trailing commas in object literals are valid according to the ECMAScript 5 (and ECMAScript 3!) spec. However, IE8 (when not in IE8 document mode) and below will throw an error when it encounters trailing commas in JavaScript.

                var foo = {
                    bar: "baz",
                    qux: "quux",
                };

                Trailing commas simplify adding and removing items to objects and arrays, since only the lines you are modifying must be touched. Another argument in favor of trailing commas is that it improves the clarity of diffs when an item is added or removed from an object or array:

                Less clear:

                var foo = {
                -    bar: "baz",
                -    qux: "quux"
                +    bar: "baz"
                 };

                More clear:

                var foo = {
                     bar: "baz",
                -    qux: "quux",
                 };

                Rule Details

                This rule enforces consistent use of trailing commas in object and array literals.

                Options

                This rule has a string option or an object option:

                {
                    "comma-dangle": ["error", "never"],
                    // or
                    "comma-dangle": ["error", {
                        "arrays": "never",
                        "objects": "never",
                        "imports": "never",
                        "exports": "never",
                        "functions": "ignore",
                    }]
                }
                • "never" (default) disallows trailing commas
                • "always" requires trailing commas
                • "always-multiline" requires trailing commas when the last element or property is in a different line than the closing ] or } and disallows trailing commas when the last element or property is on the same line as the closing ] or }
                • "only-multiline" allows (but does not require) trailing commas when the last element or property is in a different line than the closing ] or } and disallows trailing commas when the last element or property is on the same line as the closing ] or }

                Trailing commas in function declarations and function calls are valid syntax since ECMAScript 2017; however, the string option does not check these situations for backwards compatibility.

                You can also use an object option to configure this rule for each type of syntax. Each of the following options can be set to "never", "always", "always-multiline", "only-multiline", or "ignore". The default for each option is "never" unless otherwise specified.

                • arrays is for array literals and array patterns of destructuring. (e.g. let [a,] = [1,];)
                • objects is for object literals and object patterns of destructuring. (e.g. let {a,} = {a: 1};)
                • imports is for import declarations of ES Modules. (e.g. import {a,} from "foo";)
                • exports is for export declarations of ES Modules. (e.g. export {a,};)
                • functions is for function declarations and function calls. (e.g. (function(a,){ })(b,);)
                  functions is set to "ignore" by default for consistency with the string option.

                never

                Examples of incorrect code for this rule with the default "never" option:

                /*eslint comma-dangle: ["error", "never"]*/
                
                var foo = {
                    bar: "baz",
                    qux: "quux",
                };
                
                var arr = [1,2,];
                
                foo({
                  bar: "baz",
                  qux: "quux",
                });

                Examples of correct code for this rule with the default "never" option:

                /*eslint comma-dangle: ["error", "never"]*/
                
                var foo = {
                    bar: "baz",
                    qux: "quux"
                };
                
                var arr = [1,2];
                
                foo({
                  bar: "baz",
                  qux: "quux"
                });

                always

                Examples of incorrect code for this rule with the "always" option:

                /*eslint comma-dangle: ["error", "always"]*/
                
                var foo = {
                    bar: "baz",
                    qux: "quux"
                };
                
                var arr = [1,2];
                
                foo({
                  bar: "baz",
                  qux: "quux"
                });

                Examples of correct code for this rule with the "always" option:

                /*eslint comma-dangle: ["error", "always"]*/
                
                var foo = {
                    bar: "baz",
                    qux: "quux",
                };
                
                var arr = [1,2,];
                
                foo({
                  bar: "baz",
                  qux: "quux",
                });

                always-multiline

                Examples of incorrect code for this rule with the "always-multiline" option:

                /*eslint comma-dangle: ["error", "always-multiline"]*/
                
                var foo = {
                    bar: "baz",
                    qux: "quux"
                };
                
                var foo = { bar: "baz", qux: "quux", };
                
                var arr = [1,2,];
                
                var arr = [1,
                    2,];
                
                var arr = [
                    1,
                    2
                ];
                
                foo({
                  bar: "baz",
                  qux: "quux"
                });

                Examples of correct code for this rule with the "always-multiline" option:

                /*eslint comma-dangle: ["error", "always-multiline"]*/
                
                var foo = {
                    bar: "baz",
                    qux: "quux",
                };
                
                var foo = {bar: "baz", qux: "quux"};
                var arr = [1,2];
                
                var arr = [1,
                    2];
                
                var arr = [
                    1,
                    2,
                ];
                
                foo({
                  bar: "baz",
                  qux: "quux",
                });

                only-multiline

                Examples of incorrect code for this rule with the "only-multiline" option:

                /*eslint comma-dangle: ["error", "only-multiline"]*/
                
                var foo = { bar: "baz", qux: "quux", };
                
                var arr = [1,2,];
                
                var arr = [1,
                    2,];

                Examples of correct code for this rule with the "only-multiline" option:

                /*eslint comma-dangle: ["error", "only-multiline"]*/
                
                var foo = {
                    bar: "baz",
                    qux: "quux",
                };
                
                var foo = {
                    bar: "baz",
                    qux: "quux"
                };
                
                var foo = {bar: "baz", qux: "quux"};
                var arr = [1,2];
                
                var arr = [1,
                    2];
                
                var arr = [
                    1,
                    2,
                ];
                
                var arr = [
                    1,
                    2
                ];
                
                foo({
                  bar: "baz",
                  qux: "quux",
                });
                
                foo({
                  bar: "baz",
                  qux: "quux"
                });

                functions

                Examples of incorrect code for this rule with the {"functions": "never"} option:

                /*eslint comma-dangle: ["error", {"functions": "never"}]*/
                
                function foo(a, b,) {
                }
                
                foo(a, b,);
                new foo(a, b,);

                Examples of correct code for this rule with the {"functions": "never"} option:

                /*eslint comma-dangle: ["error", {"functions": "never"}]*/
                
                function foo(a, b) {
                }
                
                foo(a, b);
                new foo(a, b);

                Examples of incorrect code for this rule with the {"functions": "always"} option:

                /*eslint comma-dangle: ["error", {"functions": "always"}]*/
                
                function foo(a, b) {
                }
                
                foo(a, b);
                new foo(a, b);

                Examples of correct code for this rule with the {"functions": "always"} option:

                /*eslint comma-dangle: ["error", {"functions": "always"}]*/
                
                function foo(a, b,) {
                }
                
                foo(a, b,);
                new foo(a, b,);

                When Not To Use It

                You can turn this rule off if you are not concerned with dangling commas. Source: http://eslint.org/docs/rules/

                Missing trailing comma.
                Open

                        state.meta

                require or disallow trailing commas (comma-dangle)

                Trailing commas in object literals are valid according to the ECMAScript 5 (and ECMAScript 3!) spec. However, IE8 (when not in IE8 document mode) and below will throw an error when it encounters trailing commas in JavaScript.

                var foo = {
                    bar: "baz",
                    qux: "quux",
                };

                Trailing commas simplify adding and removing items to objects and arrays, since only the lines you are modifying must be touched. Another argument in favor of trailing commas is that it improves the clarity of diffs when an item is added or removed from an object or array:

                Less clear:

                var foo = {
                -    bar: "baz",
                -    qux: "quux"
                +    bar: "baz"
                 };

                More clear:

                var foo = {
                     bar: "baz",
                -    qux: "quux",
                 };

                Rule Details

                This rule enforces consistent use of trailing commas in object and array literals.

                Options

                This rule has a string option or an object option:

                {
                    "comma-dangle": ["error", "never"],
                    // or
                    "comma-dangle": ["error", {
                        "arrays": "never",
                        "objects": "never",
                        "imports": "never",
                        "exports": "never",
                        "functions": "ignore",
                    }]
                }
                • "never" (default) disallows trailing commas
                • "always" requires trailing commas
                • "always-multiline" requires trailing commas when the last element or property is in a different line than the closing ] or } and disallows trailing commas when the last element or property is on the same line as the closing ] or }
                • "only-multiline" allows (but does not require) trailing commas when the last element or property is in a different line than the closing ] or } and disallows trailing commas when the last element or property is on the same line as the closing ] or }

                Trailing commas in function declarations and function calls are valid syntax since ECMAScript 2017; however, the string option does not check these situations for backwards compatibility.

                You can also use an object option to configure this rule for each type of syntax. Each of the following options can be set to "never", "always", "always-multiline", "only-multiline", or "ignore". The default for each option is "never" unless otherwise specified.

                • arrays is for array literals and array patterns of destructuring. (e.g. let [a,] = [1,];)
                • objects is for object literals and object patterns of destructuring. (e.g. let {a,} = {a: 1};)
                • imports is for import declarations of ES Modules. (e.g. import {a,} from "foo";)
                • exports is for export declarations of ES Modules. (e.g. export {a,};)
                • functions is for function declarations and function calls. (e.g. (function(a,){ })(b,);)
                  functions is set to "ignore" by default for consistency with the string option.

                never

                Examples of incorrect code for this rule with the default "never" option:

                /*eslint comma-dangle: ["error", "never"]*/
                
                var foo = {
                    bar: "baz",
                    qux: "quux",
                };
                
                var arr = [1,2,];
                
                foo({
                  bar: "baz",
                  qux: "quux",
                });

                Examples of correct code for this rule with the default "never" option:

                /*eslint comma-dangle: ["error", "never"]*/
                
                var foo = {
                    bar: "baz",
                    qux: "quux"
                };
                
                var arr = [1,2];
                
                foo({
                  bar: "baz",
                  qux: "quux"
                });

                always

                Examples of incorrect code for this rule with the "always" option:

                /*eslint comma-dangle: ["error", "always"]*/
                
                var foo = {
                    bar: "baz",
                    qux: "quux"
                };
                
                var arr = [1,2];
                
                foo({
                  bar: "baz",
                  qux: "quux"
                });

                Examples of correct code for this rule with the "always" option:

                /*eslint comma-dangle: ["error", "always"]*/
                
                var foo = {
                    bar: "baz",
                    qux: "quux",
                };
                
                var arr = [1,2,];
                
                foo({
                  bar: "baz",
                  qux: "quux",
                });

                always-multiline

                Examples of incorrect code for this rule with the "always-multiline" option:

                /*eslint comma-dangle: ["error", "always-multiline"]*/
                
                var foo = {
                    bar: "baz",
                    qux: "quux"
                };
                
                var foo = { bar: "baz", qux: "quux", };
                
                var arr = [1,2,];
                
                var arr = [1,
                    2,];
                
                var arr = [
                    1,
                    2
                ];
                
                foo({
                  bar: "baz",
                  qux: "quux"
                });

                Examples of correct code for this rule with the "always-multiline" option:

                /*eslint comma-dangle: ["error", "always-multiline"]*/
                
                var foo = {
                    bar: "baz",
                    qux: "quux",
                };
                
                var foo = {bar: "baz", qux: "quux"};
                var arr = [1,2];
                
                var arr = [1,
                    2];
                
                var arr = [
                    1,
                    2,
                ];
                
                foo({
                  bar: "baz",
                  qux: "quux",
                });

                only-multiline

                Examples of incorrect code for this rule with the "only-multiline" option:

                /*eslint comma-dangle: ["error", "only-multiline"]*/
                
                var foo = { bar: "baz", qux: "quux", };
                
                var arr = [1,2,];
                
                var arr = [1,
                    2,];

                Examples of correct code for this rule with the "only-multiline" option:

                /*eslint comma-dangle: ["error", "only-multiline"]*/
                
                var foo = {
                    bar: "baz",
                    qux: "quux",
                };
                
                var foo = {
                    bar: "baz",
                    qux: "quux"
                };
                
                var foo = {bar: "baz", qux: "quux"};
                var arr = [1,2];
                
                var arr = [1,
                    2];
                
                var arr = [
                    1,
                    2,
                ];
                
                var arr = [
                    1,
                    2
                ];
                
                foo({
                  bar: "baz",
                  qux: "quux",
                });
                
                foo({
                  bar: "baz",
                  qux: "quux"
                });

                functions

                Examples of incorrect code for this rule with the {"functions": "never"} option:

                /*eslint comma-dangle: ["error", {"functions": "never"}]*/
                
                function foo(a, b,) {
                }
                
                foo(a, b,);
                new foo(a, b,);

                Examples of correct code for this rule with the {"functions": "never"} option:

                /*eslint comma-dangle: ["error", {"functions": "never"}]*/
                
                function foo(a, b) {
                }
                
                foo(a, b);
                new foo(a, b);

                Examples of incorrect code for this rule with the {"functions": "always"} option:

                /*eslint comma-dangle: ["error", {"functions": "always"}]*/
                
                function foo(a, b) {
                }
                
                foo(a, b);
                new foo(a, b);

                Examples of correct code for this rule with the {"functions": "always"} option:

                /*eslint comma-dangle: ["error", {"functions": "always"}]*/
                
                function foo(a, b,) {
                }
                
                foo(a, b,);
                new foo(a, b,);

                When Not To Use It

                You can turn this rule off if you are not concerned with dangling commas. Source: http://eslint.org/docs/rules/

                Unexpected parentheses around single function argument having a body with no curly braces
                Open

                    extensionMetaPaths.paths.forEach((path) =>

                Require parens in arrow function arguments (arrow-parens)

                Arrow functions can omit parentheses when they have exactly one parameter. In all other cases the parameter(s) must be wrapped in parentheses. This rule enforces the consistent use of parentheses in arrow functions.

                Rule Details

                This rule enforces parentheses around arrow function parameters regardless of arity. For example:

                /*eslint-env es6*/
                
                // Bad
                a => {}
                
                // Good
                (a) => {}

                Following this style will help you find arrow functions (=>) which may be mistakenly included in a condition when a comparison such as >= was the intent.

                /*eslint-env es6*/
                
                // Bad
                if (a => 2) {
                }
                
                // Good
                if (a >= 2) {
                }

                The rule can also be configured to discourage the use of parens when they are not required:

                /*eslint-env es6*/
                
                // Bad
                (a) => {}
                
                // Good
                a => {}

                Options

                This rule has a string option and an object one.

                String options are:

                • "always" (default) requires parens around arguments in all cases.
                • "as-needed" allows omitting parens when there is only one argument.

                Object properties for variants of the "as-needed" option:

                • "requireForBlockBody": true modifies the as-needed rule in order to require parens if the function body is in an instructions block (surrounded by braces).

                always

                Examples of incorrect code for this rule with the default "always" option:

                /*eslint arrow-parens: ["error", "always"]*/
                /*eslint-env es6*/
                
                a => {};
                a => a;
                a => {'\n'};
                a.then(foo => {});
                a.then(foo => a);
                a(foo => { if (true) {} });

                Examples of correct code for this rule with the default "always" option:

                /*eslint arrow-parens: ["error", "always"]*/
                /*eslint-env es6*/
                
                () => {};
                (a) => {};
                (a) => a;
                (a) => {'\n'}
                a.then((foo) => {});
                a.then((foo) => { if (true) {} });

                If Statements

                One of benefits of this option is that it prevents the incorrect use of arrow functions in conditionals:

                /*eslint-env es6*/
                
                var a = 1;
                var b = 2;
                // ...
                if (a => b) {
                 console.log('bigger');
                } else {
                 console.log('smaller');
                }
                // outputs 'bigger', not smaller as expected

                The contents of the if statement is an arrow function, not a comparison.

                If the arrow function is intentional, it should be wrapped in parens to remove ambiguity.

                /*eslint-env es6*/
                
                var a = 1;
                var b = 0;
                // ...
                if ((a) => b) {
                 console.log('truthy value returned');
                } else {
                 console.log('falsey value returned');
                }
                // outputs 'truthy value returned'

                The following is another example of this behavior:

                /*eslint-env es6*/
                
                var a = 1, b = 2, c = 3, d = 4;
                var f = a => b ? c: d;
                // f = ?

                f is an arrow function which takes a as an argument and returns the result of b ? c: d.

                This should be rewritten like so:

                /*eslint-env es6*/
                
                var a = 1, b = 2, c = 3, d = 4;
                var f = (a) => b ? c: d;

                as-needed

                Examples of incorrect code for this rule with the "as-needed" option:

                /*eslint arrow-parens: ["error", "as-needed"]*/
                /*eslint-env es6*/
                
                (a) => {};
                (a) => a;
                (a) => {'\n'};
                a.then((foo) => {});
                a.then((foo) => a);
                a((foo) => { if (true) {} });

                Examples of correct code for this rule with the "as-needed" option:

                /*eslint arrow-parens: ["error", "as-needed"]*/
                /*eslint-env es6*/
                
                () => {};
                a => {};
                a => a;
                a => {'\n'};
                a.then(foo => {});
                a.then(foo => { if (true) {} });
                (a, b, c) => a;
                (a = 10) => a;
                ([a, b]) => a;
                ({a, b}) => a;

                requireForBlockBody

                Examples of incorrect code for the { "requireForBlockBody": true } option:

                /*eslint arrow-parens: [2, "as-needed", { "requireForBlockBody": true }]*/
                /*eslint-env es6*/
                
                (a) => a;
                a => {};
                a => {'\n'};
                a.map((x) => x * x);
                a.map(x => {
                  return x * x;
                });
                a.then(foo => {});

                Examples of correct code for the { "requireForBlockBody": true } option:

                /*eslint arrow-parens: [2, "as-needed", { "requireForBlockBody": true }]*/
                /*eslint-env es6*/
                
                (a) => {};
                (a) => {'\n'};
                a => ({});
                () => {};
                a => a;
                a.then((foo) => {});
                a.then((foo) => { if (true) {} });
                a((foo) => { if (true) {} });
                (a, b, c) => a;
                (a = 10) => a;
                ([a, b]) => a;
                ({a, b}) => a;

                Further Reading

                Unexpected parentheses around single function argument having a body with no curly braces
                Open

                        return !extension.some((e) => extensions.indexOf(e) !== -1);

                Require parens in arrow function arguments (arrow-parens)

                Arrow functions can omit parentheses when they have exactly one parameter. In all other cases the parameter(s) must be wrapped in parentheses. This rule enforces the consistent use of parentheses in arrow functions.

                Rule Details

                This rule enforces parentheses around arrow function parameters regardless of arity. For example:

                /*eslint-env es6*/
                
                // Bad
                a => {}
                
                // Good
                (a) => {}

                Following this style will help you find arrow functions (=>) which may be mistakenly included in a condition when a comparison such as >= was the intent.

                /*eslint-env es6*/
                
                // Bad
                if (a => 2) {
                }
                
                // Good
                if (a >= 2) {
                }

                The rule can also be configured to discourage the use of parens when they are not required:

                /*eslint-env es6*/
                
                // Bad
                (a) => {}
                
                // Good
                a => {}

                Options

                This rule has a string option and an object one.

                String options are:

                • "always" (default) requires parens around arguments in all cases.
                • "as-needed" allows omitting parens when there is only one argument.

                Object properties for variants of the "as-needed" option:

                • "requireForBlockBody": true modifies the as-needed rule in order to require parens if the function body is in an instructions block (surrounded by braces).

                always

                Examples of incorrect code for this rule with the default "always" option:

                /*eslint arrow-parens: ["error", "always"]*/
                /*eslint-env es6*/
                
                a => {};
                a => a;
                a => {'\n'};
                a.then(foo => {});
                a.then(foo => a);
                a(foo => { if (true) {} });

                Examples of correct code for this rule with the default "always" option:

                /*eslint arrow-parens: ["error", "always"]*/
                /*eslint-env es6*/
                
                () => {};
                (a) => {};
                (a) => a;
                (a) => {'\n'}
                a.then((foo) => {});
                a.then((foo) => { if (true) {} });

                If Statements

                One of benefits of this option is that it prevents the incorrect use of arrow functions in conditionals:

                /*eslint-env es6*/
                
                var a = 1;
                var b = 2;
                // ...
                if (a => b) {
                 console.log('bigger');
                } else {
                 console.log('smaller');
                }
                // outputs 'bigger', not smaller as expected

                The contents of the if statement is an arrow function, not a comparison.

                If the arrow function is intentional, it should be wrapped in parens to remove ambiguity.

                /*eslint-env es6*/
                
                var a = 1;
                var b = 0;
                // ...
                if ((a) => b) {
                 console.log('truthy value returned');
                } else {
                 console.log('falsey value returned');
                }
                // outputs 'truthy value returned'

                The following is another example of this behavior:

                /*eslint-env es6*/
                
                var a = 1, b = 2, c = 3, d = 4;
                var f = a => b ? c: d;
                // f = ?

                f is an arrow function which takes a as an argument and returns the result of b ? c: d.

                This should be rewritten like so:

                /*eslint-env es6*/
                
                var a = 1, b = 2, c = 3, d = 4;
                var f = (a) => b ? c: d;

                as-needed

                Examples of incorrect code for this rule with the "as-needed" option:

                /*eslint arrow-parens: ["error", "as-needed"]*/
                /*eslint-env es6*/
                
                (a) => {};
                (a) => a;
                (a) => {'\n'};
                a.then((foo) => {});
                a.then((foo) => a);
                a((foo) => { if (true) {} });

                Examples of correct code for this rule with the "as-needed" option:

                /*eslint arrow-parens: ["error", "as-needed"]*/
                /*eslint-env es6*/
                
                () => {};
                a => {};
                a => a;
                a => {'\n'};
                a.then(foo => {});
                a.then(foo => { if (true) {} });
                (a, b, c) => a;
                (a = 10) => a;
                ([a, b]) => a;
                ({a, b}) => a;

                requireForBlockBody

                Examples of incorrect code for the { "requireForBlockBody": true } option:

                /*eslint arrow-parens: [2, "as-needed", { "requireForBlockBody": true }]*/
                /*eslint-env es6*/
                
                (a) => a;
                a => {};
                a => {'\n'};
                a.map((x) => x * x);
                a.map(x => {
                  return x * x;
                });
                a.then(foo => {});

                Examples of correct code for the { "requireForBlockBody": true } option:

                /*eslint arrow-parens: [2, "as-needed", { "requireForBlockBody": true }]*/
                /*eslint-env es6*/
                
                (a) => {};
                (a) => {'\n'};
                a => ({});
                () => {};
                a => a;
                a.then((foo) => {});
                a.then((foo) => { if (true) {} });
                a((foo) => { if (true) {} });
                (a, b, c) => a;
                (a = 10) => a;
                ([a, b]) => a;
                ({a, b}) => a;

                Further Reading

                Identical blocks of code found in 2 locations. Consider refactoring.
                Open

                function notInExtensions(extensions, extension) {
                    if (Array.isArray(extension)) {
                        return !extension.some((e) => extensions.indexOf(e) !== -1);
                    }
                
                
                Severity: Major
                Found in src/context/extensions/helpers/processConfig.js and 1 other location - About 1 hr to fix
                src/context/extensions/helpers/processCommands.js on lines 78..84

                Duplicated Code

                Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                Tuning

                This issue has a mass of 73.

                We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                Refactorings

                Further Reading

                There are no issues that match your filters.

                Category
                Status