revamp plugin logic & enable all enums

Author: zachbryant

docs/rules/enum.md

@@ -0,0 +1,198 @@
+# require enum members to be sorted (enum)
+
+When declaring multiple members on an enum, some developers prefer to sort enum member names alphabetically to be able to find necessary members easier at the later time. Others feel that it adds complexity and becomes burden to maintain.
+
+## Rule Details
+
+This rule checks all members of an enum declaration and verifies that all keys are sorted alphabetically.
+
+Examples of **incorrect** code for this rule:
+
+```ts
+/* eslint typescript-sort-keys/enum: "error" */
+
+enum U {
+  a = 'T',
+  c = 'T',
+  b = 'T',
+}
+
+// Case-sensitive by default.
+enum U {
+  a = 'T',
+  b = 'T',
+  C = 'T',
+}
+
+enum U {
+  a = 'T',
+  'c' = 'T',
+  b = 'T',
+}
+```
+
+Examples of **correct** code for this rule:
+
+```ts
+/* eslint typescript-sort-keys/enum: "error" */
+
+enum U {
+  a = 'T',
+  b = 'T',
+  c = 'T',
+}
+
+// Case-sensitive by default.
+enum U {
+  C = 'T',
+  a = 'T',
+  b = 'T',
+}
+
+// This rule sorts members which have an arbitrary string literal name as well.
+enum U {
+  a = 'T',
+  'b+-' = 'T',
+  c = 'T',
+}
+```
+
+## Options
+
+```json
+{
+  "typescript-sort-keys/enum": ["error", "asc", { "caseSensitive": true, "natural": false }]
+}
+```
+
+The 1st option is `"asc"` or `"desc"`.
+
+- `"asc"` (default) - enforce enum members to be in ascending order.
+- `"desc"` - enforce enum members to be in descending order.
+
+The 2nd option is an object which has 2 properties.
+
+- `caseSensitive` - if `true`, enforce enum members to be in case-sensitive order. Default is `true`.
+- `natural` - if `true`, enforce enum members 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.
+
+### desc
+
+Examples of **incorrect** code for the `"desc"` option:
+
+```ts
+/* eslint typescript-sort-keys/enum: ["error", "desc"] */
+
+enum U {
+  b = 'T',
+  c = 'T',
+  a = 'T',
+}
+enum U {
+  b = 'T',
+  c = 'T',
+  a = 'T',
+}
+
+// Case-sensitive by default.
+enum U {
+  a = 'T',
+  B = 'T',
+  c = 'T',
+}
+```
+
+Examples of **correct** code for the `"desc"` option:
+
+```ts
+/* eslint typescript-sort-keys/enum: ["error", "desc"] */
+
+enum U {
+  c = 'T',
+  b = 'T',
+  a = 'T',
+}
+enum U {
+  c = 'T',
+  b = 'T',
+  a = 'T',
+}
+
+// Case-sensitive by default.
+enum U {
+  c = 'T',
+  a = 'T',
+  B = 'T',
+}
+```
+
+### insensitive
+
+Examples of **incorrect** code for the `{ caseSensitive: false }` option:
+
+```ts
+/* eslint typescript-sort-keys/enum: ["error", "asc", { caseSensitive: false }] */
+
+enum U {
+  a = 'T',
+  c = 'T',
+  C = 'T',
+  b = 'T',
+}
+enum U {
+  a = 'T',
+  C = 'T',
+  c = 'T',
+  b = 'T',
+}
+```
+
+Examples of **correct** code for the `{ caseSensitive: false }` option:
+
+```ts
+/* eslint typescript-sort-keys/enum: ["error", "asc", { caseSensitive: false }] */
+
+enum U {
+  a = 'T',
+  b = 'T',
+  c = 'T',
+  C = 'T',
+}
+enum U {
+  a = 'T',
+  b = 'T',
+  C = 'T',
+  c = 'T',
+}
+```
+
+### natural
+
+Examples of **incorrect** code for the `{natural: true}` option:
+
+```ts
+/* eslint typescript-sort-keys/enum: ["error", "asc", { natural: true }] */
+
+enum U {
+  a = 'T',
+  _ = 'T',
+  A = 'T',
+  $ = 'T',
+}
+```
+
+Examples of **correct** code for the `{natural: true}` option:
+
+```ts
+/* eslint typescript-sort-keys/enum: ["error", "asc", { natural: true }] */
+
+enum U {
+  a = 'T',
+  A = 'T',
+  _ = 'T',
+  $ = 'T',
+}
+```
+
+## When Not To Use It
+
+If you don't want to notify about enum members' order, then it's safe to disable this rule.

docs/rules/string-enum.md

@@ -1,10 +1,14 @@
-# require string enum members to be sorted (string-enum)
+# Deprecation notice: This rule has been deprecated in favor of [typescript-sort-keys/enum](./enum.md). `string-enum` will continue to sort only string enums and may be removed in future updates.
 
-When declaring multiple members on an string enum, some developers prefer to sort enum member names alphabetically to be able to find necessary members easier at the later time. Others feel that it adds complexity and becomes burden to maintain.
+---
+
+# require string-enum members to be sorted (string-enum)
+
+When declaring multiple members on a string-enum, some developers prefer to sort string-enum member names alphabetically to be able to find necessary members easier at the later time. Others feel that it adds complexity and becomes burden to maintain.
 
 ## Rule Details
 
-This rule checks all members of a string enum declaration and verifies that all keys are sorted alphabetically.
+This rule checks all members of a string-enum declaration and verifies that all keys are sorted alphabetically.
 
 Examples of **incorrect** code for this rule:
 
@@ -77,13 +81,13 @@ enum U {
 
 The 1st option is `"asc"` or `"desc"`.
 
-- `"asc"` (default) - enforce enum members to be in ascending order.
-- `"desc"` - enforce enum members to be in descending order.
+- `"asc"` (default) - enforce string-enum members to be in ascending order.
+- `"desc"` - enforce string-enum members to be in descending order.
 
 The 2nd option is an object which has 2 properties.
 
-- `caseSensitive` - if `true`, enforce enum members to be in case-sensitive order. Default is `true`.
-- `natural` - if `true`, enforce enum members 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.
+- `caseSensitive` - if `true`, enforce string-enum members to be in case-sensitive order. Default is `true`.
+- `natural` - if `true`, enforce string-enum members 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.
 
 ### desc
 
@@ -205,4 +209,4 @@ enum U {
 
 ## When Not To Use It
 
-If you don't want to notify about enum members' order, then it's safe to disable this rule.
+If you don't want to notify about string-enum members' order, then it's safe to disable this rule.

package.json

@@ -1,7 +1,7 @@
 {
   "name": "eslint-plugin-typescript-sort-keys",
   "version": "3.1.0",
-  "description": "Sort interface and string enum keys",
+  "description": "Sort interface and enum keys",
   "keywords": [
     "eslint",
     "eslintplugin",

src/common/options.ts

@@ -1,35 +1,35 @@
-import { JSONSchema4 } from 'json-schema'
-
-export enum SortingOrder {
-  Ascending = 'asc',
-  Descending = 'desc',
-}
-
-export const sortingOrderOptionSchema: JSONSchema4 = {
-  enum: [SortingOrder.Ascending, SortingOrder.Descending],
-}
-
-export type SortingOrderOption = SortingOrder
-
-interface CaseSensitiveSortingOption {
-  readonly caseSensitive: boolean
-}
-
-interface NaturalSortingOption {
-  readonly natural: boolean
-}
-
-interface RequiredFirstSortingOption {
-  readonly requiredFirst: boolean
-}
-
-export interface SortingParamsOptions {
-  readonly caseSensitive: CaseSensitiveSortingOption
-  readonly natural: NaturalSortingOption
-  readonly requiredFirst: RequiredFirstSortingOption
+import {
+  AllRuleOptions,
+  CreateReporterArgs,
+  SortingOrder,
+  SortingParamsOptions,
+} from '../types'
+
+export const defaultSortingOrder = SortingOrder.Ascending
+export const defaultOptions: SortingParamsOptions = {
+  caseSensitive: true,
+  natural: false,
+  requiredFirst: false,
 }
 
-export enum ErrorMessage {
-  InterfaceInvalidOrder = `Expected interface keys to be in {{ requiredFirst }}{{ natural }}{{ insensitive }}{{ order }}ending order. '{{ thisName }}' should be before '{{ prevName }}'.`,
-  StringEnumInvalidOrder = `Expected string enum members to be in {{ natural }}{{ insensitive }}{{ order }}ending order. '{{ thisName }}' should be before '{{ prevName }}'.`,
+/**
+ * Get the options from the context
+ */
+export function getOptions(
+  context: CreateReporterArgs<string, AllRuleOptions>['context'],
+) {
+  const order = context.options[0] || defaultSortingOrder
+  const options = context.options[1]
+  const isAscending = order === SortingOrder.Ascending
+  const isInsensitive = !(options?.caseSensitive ?? defaultOptions.caseSensitive)
+  const isNatural = options?.natural ?? defaultOptions.natural
+  const isRequiredFirst = options?.requiredFirst ?? defaultOptions.requiredFirst
+
+  return {
+    isAscending,
+    isInsensitive,
+    isNatural,
+    isRequiredFirst,
+    order,
+  }
 }

src/config/constants.ts

@@ -0,0 +1 @@
+export const PLUGIN_NAME = 'typescript-sort-keys'

src/config/recommended.config.ts

@@ -0,0 +1,9 @@
+import { PLUGIN_NAME } from './constants'
+
+export default {
+  plugins: [PLUGIN_NAME],
+  rules: {
+    [`${PLUGIN_NAME}/interface`]: 'error' as const,
+    [`${PLUGIN_NAME}/enum`]: 'error' as const,
+  },
+}

src/config/recommended.ts

@@ -0,0 +1,17 @@
+import { Linter } from '@typescript-eslint/utils/ts-eslint'
+
+import { defaultOptions, defaultSortingOrder } from '../common/options'
+import { PLUGIN_NAME } from './constants'
+import recommended from './recommended.config'
+
+export default {
+  plugins: recommended.plugins,
+  rules: {
+    ...recommended.rules,
+    [`${PLUGIN_NAME}/interface`]: [
+      'error' as const,
+      defaultSortingOrder,
+      { ...defaultOptions, requiredFirst: true },
+    ] as Linter.RuleEntry,
+  },
+}

src/config/requiredFirst.config.ts

@@ -0,0 +1,34 @@
+import { TSESLint } from '@typescript-eslint/utils'
+import { ReportFixFunction } from '@typescript-eslint/utils/ts-eslint'
+
+import { AllRuleOptions, CreateReporterArgs, Node, SourceCode, TSType } from './types'
+import { getMemoized, memoize } from './utils/memo'
+import { getBodyRange, getFixedBodyText } from './utils/sourcecode'
+
+export const getFixerFunction = (
+  baseMemoKey: string,
+  createReporterArgs: Pick<CreateReporterArgs<string, AllRuleOptions>, 'context'>,
+  body: TSType[],
+  sortedBody: TSType[],
+): ReportFixFunction =>
+  function* (fixer: TSESLint.RuleFixer) {
+    const sourceCode = createReporterArgs.context.getSourceCode() as SourceCode
+
+    const bodyRange = memoize(`bodyRange_${baseMemoKey}`, () =>
+      getBodyRange(sourceCode, body as unknown as Node[]),
+    )
+
+    const fixedBodyTextMemoKey = `fixedBodyText_${baseMemoKey}`
+    // Replace the entire body with the sorted body
+    const fixedBodyText =
+      getMemoized(fixedBodyTextMemoKey) ??
+      memoize(fixedBodyTextMemoKey, () =>
+        getFixedBodyText(
+          sourceCode,
+          sortedBody as unknown as Node[],
+          body as unknown as Node[],
+        ),
+      )
+
+    yield fixer.replaceTextRange(bodyRange, fixedBodyText)
+  }

src/fixer.ts

@@ -1,4 +1,4 @@
-import recommended from './config/recommended'
+import recommended from './config/recommended.config'
 import { rules } from './rules'
 
 const config = {