eslint
diff --git a/‎docs/src/rules/sort-keys.md
Lines changed: 30 additions & 0 deletions b/‎docs/src/rules/sort-keys.md
Lines changed: 30 additions & 0 deletions
diff --git a/‎lib/rules/sort-keys.js
Lines changed: 10 additions & 1 deletion b/‎lib/rules/sort-keys.js
Lines changed: 10 additions & 1 deletion
diff --git a/‎tests/lib/rules/sort-keys.js
Lines changed: 30 additions & 0 deletions b/‎tests/lib/rules/sort-keys.js
Lines changed: 30 additions & 0 deletions
@@ -89,6 +89,7 @@ The 2nd option is an object which has the following properties.
 * `minKeys` - Specifies the minimum number of keys that an object should have in order for the object's unsorted keys to produce an error. Default is `2`, which means by default all objects with unsorted keys will result in lint errors.
 * `natural` - if `true`, enforce properties to be in natural order. Default is `false`. Natural Order compares strings containing combination of letters and numbers in the way a human being would sort. It basically sorts numerically, instead of sorting alphabetically. So the number 10 comes after the number 3 in Natural Sorting.
 * `allowLineSeparatedGroups` - if `true`, the rule allows to group object keys through line breaks. In other words, a blank line after a property will reset the sorting of keys. Default is `false`.
+* `ignoreComputedKeys` - if `true`, the rule ignores all computed keys and doesn't report unsorted properties separated by them. A computed key will reset the sorting of the following non-computed keys. Default is `false`.
 
 Example for a list:
 
@@ -372,6 +373,35 @@ var obj7 = {
 
 :::
 
+### ignoreComputedKeys
+
+Examples of **correct** code for the `{ignoreComputedKeys: true}` option:
+
+::: correct
+
+```js
+/*eslint sort-keys: ["error", "asc", {ignoreComputedKeys: true}]*/
+
+let obj1 = {
+    [b]: 1,
+    a: 2
+}
+
+let obj2 = {
+    c: 1,
+    [b]: 2,
+    a: 3
+}
+
+let obj3 = {
+    c: 1,
+    ["b"]: 2,
+    a: 3
+}
+```
+
+:::
+
 ## When Not To Use It
 
 If you don't want to notify about properties' order, then it's safe to disable this rule.
 
@@ -83,6 +83,7 @@ module.exports = {
         defaultOptions: ["asc", {
             allowLineSeparatedGroups: false,
             caseSensitive: true,
+            ignoreComputedKeys: false,
             minKeys: 2,
             natural: false
         }],
@@ -112,6 +113,9 @@ module.exports = {
                     },
                     allowLineSeparatedGroups: {
                         type: "boolean"
+                    },
+                    ignoreComputedKeys: {
+                        type: "boolean"
                     }
                 },
                 additionalProperties: false
@@ -124,7 +128,7 @@ module.exports = {
     },
 
     create(context) {
-        const [order, { caseSensitive, natural, minKeys, allowLineSeparatedGroups }] = context.options;
+        const [order, { caseSensitive, natural, minKeys, allowLineSeparatedGroups, ignoreComputedKeys }] = context.options;
         const insensitive = !caseSensitive;
         const isValidOrder = isValidOrders[
             order + (insensitive ? "I" : "") + (natural ? "N" : "")
@@ -160,6 +164,11 @@ module.exports = {
                     return;
                 }
 
+                if (ignoreComputedKeys && node.computed) {
+                    stack.prevName = null; // reset sort
+                    return;
+                }
+
                 const prevName = stack.prevName;
                 const numKeys = stack.numKeys;
                 const thisName = getPropertyName(node);
 
@@ -358,6 +358,20 @@ ruleTester.run("sort-keys", rule, {
             `,
             options: ["asc", { allowLineSeparatedGroups: true }],
             languageOptions: { ecmaVersion: 2018 }
+
+        // ignoreComputedKeys
+        {
+            code: "var obj = { ['b']: 1, a: 2 }",
+            options: ["asc", { ignoreComputedKeys: true }]
+        },
+        {
+            code: "var obj = { a: 1, [c]: 2, b: 3 }",
+            options: ["asc", { ignoreComputedKeys: true }]
+        },
+        {
+            code: "var obj = { c: 1, ['b']: 2, a: 3 }",
+            options: ["asc", { ignoreComputedKeys: true }]
         }
     ],
     invalid: [
@@ -2268,6 +2282,22 @@ ruleTester.run("sort-keys", rule, {
                     }
                 }
             ]
+        },
+        {
+            code: "var obj = { d: 1, ['c']: 2, b: 3, a: 4 }",
+            options: ["asc", { ignoreComputedKeys: true, minKeys: 4 }],
+            errors: [
+                {
+                    messageId: "sortKeys",
+                    data: {
+                        natural: "",
+                        insensitive: "",
+                        order: "asc",
+                        thisName: "a",
+                        prevName: "b"
+                    }
+                }
+            ]
         }
     ]
 });