eslint-plugin-perfectionist 4.2.0 → 4.4.0

package/dist/alphabet.d.ts

@@ -0,0 +1,176 @@
+/**
+ * Utility class to build alphabets
+ */
+export declare class Alphabet {
+  private _characters
+  private constructor()
+  /**
+   * Generates an alphabet from the given characters.
+   * @param {string|string[]} values - The characters to generate the alphabet from
+   * @returns {Alphabet} - The wrapped alphabet
+   */
+  static generateFrom(values: string[] | string): Alphabet
+  /**
+   * Generates an alphabet containing relevant characters from the Unicode
+   * standard. Contains the Unicode planes 0 and 1.
+   * @returns {Alphabet} - The generated alphabet
+   */
+  static generateRecommendedAlphabet(): Alphabet
+  /**
+   * Generates an alphabet containing all characters from the Unicode standard
+   * except for irrelevant Unicode planes.
+   * Contains the Unicode planes 0, 1, 2 and 3.
+   * @returns {Alphabet} - The generated alphabet
+   */
+  static generateCompleteAlphabet(): Alphabet
+  private static _convertCodepointToCharacter
+  /**
+   * Generates an alphabet containing relevant characters from the Unicode
+   * standard.
+   * @param {number} maxCodePoint - The maximum code point to generate the
+   * alphabet to
+   * @returns {Alphabet} - The generated alphabet
+   */
+  private static _generateAlphabetToRange
+  /**
+   * For each character with a lower and upper case, permutes the two cases
+   * so that the alphabet is ordered by the case priority entered.
+   * @param {string} casePriority - The case to prioritize
+   * @returns {Alphabet} - The same alphabet instance with the cases prioritized
+   * @example
+   * Alphabet.generateFrom('aAbBcdCD')
+   * .prioritizeCase('uppercase')
+   * // Returns 'AaBbCDcd'
+   */
+  prioritizeCase(casePriority: 'lowercase' | 'uppercase'): this
+  /**
+   * Adds specific characters to the end of the alphabet.
+   * @param {string|string[]} values - The characters to push to the alphabet
+   * @returns {Alphabet} - The same alphabet instance without the specified
+   * characters
+   * @example
+   * Alphabet.generateFrom('ab')
+   * .pushCharacters('cd')
+   * // Returns 'abcd'
+   */
+  pushCharacters(values: string[] | string): this
+  /**
+   * Permutes characters with cases so that all characters with the entered case
+   * are put before the other characters.
+   * @param {string} caseToComeFirst - The case to put before the other
+   * characters
+   * @returns {Alphabet} - The same alphabet instance with all characters with
+   * case before all the characters with the other case
+   */
+  placeAllWithCaseBeforeAllWithOtherCase(
+    caseToComeFirst: 'uppercase' | 'lowercase',
+  ): this
+  /**
+   * Places a specific character right before another character in the alphabet.
+   * @param {object} params - The parameters for the operation
+   * @param {string} params.characterBefore - The character to come before
+   * characterAfter
+   * @param {string} params.characterAfter - The target character
+   * @returns {Alphabet} - The same alphabet instance with the specific
+   * character prioritized
+   * @example
+   * Alphabet.generateFrom('ab-cd/')
+   * .placeCharacterBefore({ characterBefore: '/', characterAfter: '-' })
+   * // Returns 'ab/-cd'
+   */
+  placeCharacterBefore({
+    characterBefore,
+    characterAfter,
+  }: {
+    characterBefore: string
+    characterAfter: string
+  }): this
+  /**
+   * Places a specific character right after another character in the alphabet.
+   * @param {object} params - The parameters for the operation
+   * @param {string} params.characterBefore - The target character
+   * @param {string} params.characterAfter - The character to come after
+   * characterBefore
+   * @returns {Alphabet} - The same alphabet instance with the specific
+   * character prioritized
+   * @example
+   * Alphabet.generateFrom('ab-cd/')
+   * .placeCharacterAfter({ characterBefore: '/', characterAfter: '-' })
+   * // Returns 'abcd/-'
+   */
+  placeCharacterAfter({
+    characterBefore,
+    characterAfter,
+  }: {
+    characterBefore: string
+    characterAfter: string
+  }): this
+  /**
+   * Removes specific characters from the alphabet by their range.
+   * @param {object} range - The Unicode range to remove characters from
+   * @param {number} range.start - The starting Unicode codepoint
+   * @param {number} range.end - The ending Unicode codepoint
+   * @returns {Alphabet} - The same alphabet instance without the characters
+   * from the specified range
+   */
+  removeUnicodeRange({ start, end }: { start: number; end: number }): this
+  /**
+   * Sorts the alphabet by the sorting function provided.
+   * @param {Function} sortingFunction - The sorting function to use
+   * @returns {Alphabet} - The same alphabet instance sorted by the sorting function provided
+   */
+  sortBy(
+    sortingFunction: (characterA: string, characterB: string) => number,
+  ): this
+  /**
+   * Removes specific characters from the alphabet.
+   * @param {string|string[]} values - The characters to remove from the
+   * alphabet
+   * @returns {Alphabet} - The same alphabet instance without the specified
+   * characters
+   * @example
+   * Alphabet.generateFrom('abcd')
+   * .removeCharacters('dcc')
+   * // Returns 'ab'
+   */
+  removeCharacters(values: string[] | string): this
+  /**
+   * Sorts the alphabet by the natural order of the characters using
+   * `natural-orderby`.
+   * @param {string} locale - The locale to use for sorting
+   * @returns {Alphabet} - The same alphabet instance sorted by the natural
+   * order of the characters
+   */
+  sortByNaturalSort(locale?: string): this
+  /**
+   * Sorts the alphabet by the character code point.
+   * @returns {Alphabet} - The same alphabet instance sorted by the character
+   * code point
+   */
+  sortByCharCodeAt(): this
+  /**
+   * Sorts the alphabet by the locale order of the characters.
+   * @param {Intl.LocalesArgument} locales - The locales to use for sorting
+   * @returns {Alphabet} - The same alphabet instance sorted by the locale
+   * order of the characters
+   */
+  sortByLocaleCompare(locales?: Intl.LocalesArgument): this
+  /**
+   * Retrieves the characters from the alphabet.
+   * @returns {string} The characters from the alphabet
+   */
+  getCharacters(): string
+  /**
+   * Reverses the alphabet.
+   * @returns {Alphabet} - The same alphabet instance reversed
+   * @example
+   * Alphabet.generateFrom('ab')
+   * .reverse()
+   * // Returns 'ba'
+   */
+  reverse(): this
+  private _placeCharacterBeforeOrAfter
+  private _getCharactersWithCase
+}
+
+export {}

package/dist/index.d.ts

@@ -30,9 +30,11 @@ declare interface PluginConfig {
     'recommended-alphabetical-legacy': Linter.LegacyConfig
     'recommended-line-length-legacy': Linter.LegacyConfig
     'recommended-natural-legacy': Linter.LegacyConfig
+    'recommended-custom-legacy': Linter.LegacyConfig
     'recommended-alphabetical': Linter.Config
     'recommended-line-length': Linter.Config
     'recommended-natural': Linter.Config
+    'recommended-custom': Linter.Config
   }
   name: string
 }

package/dist/index.js

@@ -77,6 +77,10 @@ const index = {
       type: 'natural',
       order: 'asc',
     }),
+    'recommended-custom-legacy': createLegacyConfig({
+      type: 'custom',
+      order: 'asc',
+    }),
     'recommended-alphabetical': createConfig({
       type: 'alphabetical',
       order: 'asc',
@@ -89,6 +93,10 @@ const index = {
       type: 'natural',
       order: 'asc',
     }),
+    'recommended-custom': createConfig({
+      type: 'custom',
+      order: 'asc',
+    }),
   },
 }
 module.exports = index

package/dist/rules/sort-array-includes-utils.js

@@ -0,0 +1,30 @@
+'use strict'
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' })
+const matches = require('../utils/matches.js')
+let customGroupMatches = props => {
+  if ('anyOf' in props.customGroup) {
+    return props.customGroup.anyOf.some(subgroup =>
+      customGroupMatches({ ...props, customGroup: subgroup }),
+    )
+  }
+  if (
+    props.customGroup.selector &&
+    !props.selectors.includes(props.customGroup.selector)
+  ) {
+    return false
+  }
+  if (
+    'elementNamePattern' in props.customGroup &&
+    props.customGroup.elementNamePattern
+  ) {
+    let matchesElementNamePattern = matches.matches(
+      props.elementName,
+      props.customGroup.elementNamePattern,
+    )
+    if (!matchesElementNamePattern) {
+      return false
+    }
+  }
+  return true
+}
+exports.customGroupMatches = customGroupMatches

package/dist/rules/sort-array-includes.js

@@ -4,56 +4,77 @@ Object.defineProperties(exports, {
   [Symbol.toStringTag]: { value: 'Module' },
 })
 const commonJsonSchemas = require('../utils/common-json-schemas.js')
+const validateGeneratedGroupsConfiguration = require('../utils/validate-generated-groups-configuration.js')
+const getCustomGroupsCompareOptions = require('../utils/get-custom-groups-compare-options.js')
+const getMatchingContextOptions = require('../utils/get-matching-context-options.js')
+const generatePredefinedGroups = require('../utils/generate-predefined-groups.js')
 const getEslintDisabledLines = require('../utils/get-eslint-disabled-lines.js')
+const sortArrayIncludes_types = require('./sort-array-includes.types.js')
 const isNodeEslintDisabled = require('../utils/is-node-eslint-disabled.js')
 const isPartitionComment = require('../utils/is-partition-comment.js')
+const createNodeIndexMap = require('../utils/create-node-index-map.js')
+const sortNodesByGroups = require('../utils/sort-nodes-by-groups.js')
 const getCommentsBefore = require('../utils/get-comments-before.js')
+const sortArrayIncludesUtils = require('./sort-array-includes-utils.js')
 const createEslintRule = require('../utils/create-eslint-rule.js')
 const getLinesBetween = require('../utils/get-lines-between.js')
+const getGroupNumber = require('../utils/get-group-number.js')
 const getSourceCode = require('../utils/get-source-code.js')
 const toSingleLine = require('../utils/to-single-line.js')
 const rangeToDiff = require('../utils/range-to-diff.js')
 const getSettings = require('../utils/get-settings.js')
 const isSortable = require('../utils/is-sortable.js')
-const sortNodes = require('../utils/sort-nodes.js')
 const makeFixes = require('../utils/make-fixes.js')
+const useGroups = require('../utils/use-groups.js')
 const complete = require('../utils/complete.js')
 const pairwise = require('../utils/pairwise.js')
+let cachedGroupsByModifiersAndSelectors = /* @__PURE__ */ new Map()
 let defaultOptions = {
   groupKind: 'literals-first',
   specialCharacters: 'keep',
   partitionByComment: false,
   partitionByNewLine: false,
+  useConfigurationIf: {},
   type: 'alphabetical',
   ignoreCase: true,
   locales: 'en-US',
+  customGroups: [],
+  alphabet: '',
   order: 'asc',
+  groups: [],
 }
 let jsonSchema = {
-  properties: {
-    partitionByComment: {
-      ...commonJsonSchemas.partitionByCommentJsonSchema,
-      description:
-        'Allows you to use comments to separate the array members into logical groups.',
+  items: {
+    properties: {
+      partitionByComment: {
+        ...commonJsonSchemas.partitionByCommentJsonSchema,
+        description:
+          'Allows you to use comments to separate the array members into logical groups.',
+      },
+      groupKind: {
+        enum: ['mixed', 'literals-first', 'spreads-first'],
+        description: 'Specifies top-level groups.',
+        type: 'string',
+      },
+      customGroups: commonJsonSchemas.buildCustomGroupsArrayJsonSchema({
+        singleCustomGroupJsonSchema:
+          sortArrayIncludes_types.singleCustomGroupJsonSchema,
+      }),
+      useConfigurationIf: commonJsonSchemas.buildUseConfigurationIfJsonSchema(),
+      type: commonJsonSchemas.buildTypeJsonSchema({ withUnsorted: true }),
+      partitionByNewLine: commonJsonSchemas.partitionByNewLineJsonSchema,
+      specialCharacters: commonJsonSchemas.specialCharactersJsonSchema,
+      ignoreCase: commonJsonSchemas.ignoreCaseJsonSchema,
+      alphabet: commonJsonSchemas.alphabetJsonSchema,
+      locales: commonJsonSchemas.localesJsonSchema,
+      groups: commonJsonSchemas.groupsJsonSchema,
+      order: commonJsonSchemas.orderJsonSchema,
     },
-    groupKind: {
-      enum: ['mixed', 'literals-first', 'spreads-first'],
-      description: 'Specifies top-level groups.',
-      type: 'string',
-    },
-    partitionByNewLine: {
-      description:
-        'Allows to use spaces to separate the nodes into logical groups.',
-      type: 'boolean',
-    },
-    specialCharacters: commonJsonSchemas.specialCharactersJsonSchema,
-    ignoreCase: commonJsonSchemas.ignoreCaseJsonSchema,
-    locales: commonJsonSchemas.localesJsonSchema,
-    order: commonJsonSchemas.orderJsonSchema,
-    type: commonJsonSchemas.typeJsonSchema,
+    additionalProperties: false,
+    type: 'object',
   },
-  additionalProperties: false,
-  type: 'object',
+  uniqueItems: true,
+  type: 'array',
 }
 const sortArrayIncludes = createEslintRule.createEslintRule({
   create: context => ({
@@ -68,38 +89,68 @@ const sortArrayIncludes = createEslintRule.createEslintRule({
           node.object.type === 'ArrayExpression'
             ? node.object.elements
             : node.object.arguments
-        sortArray(context, 'unexpectedArrayIncludesOrder', elements)
+        sortArray({
+          availableMessageIds: {
+            unexpectedGroupOrder: 'unexpectedArrayIncludesGroupOrder',
+            unexpectedOrder: 'unexpectedArrayIncludesOrder',
+          },
+          elements,
+          context,
+        })
       }
     },
   }),
   meta: {
+    messages: {
+      unexpectedArrayIncludesGroupOrder:
+        'Expected "{{right}}" ({{rightGroup}}) to come before "{{left}}" ({{leftGroup}}).',
+      unexpectedArrayIncludesOrder:
+        'Expected "{{right}}" to come before "{{left}}".',
+    },
     docs: {
       description: 'Enforce sorted arrays before include method.',
       url: 'https://perfectionist.dev/rules/sort-array-includes',
       recommended: true,
     },
-    messages: {
-      unexpectedArrayIncludesOrder:
-        'Expected "{{right}}" to come before "{{left}}".',
-    },
-    schema: [jsonSchema],
+    schema: jsonSchema,
     type: 'suggestion',
     fixable: 'code',
   },
   defaultOptions: [defaultOptions],
   name: 'sort-array-includes',
 })
-let sortArray = (context, messageId, elements) => {
+let sortArray = ({ availableMessageIds, elements, context }) => {
   if (!isSortable.isSortable(elements)) {
     return
   }
+  let sourceCode = getSourceCode.getSourceCode(context)
   let settings = getSettings.getSettings(context.settings)
-  let options = complete.complete(
-    context.options.at(0),
+  let matchedContextOptions =
+    getMatchingContextOptions.getMatchingContextOptions({
+      nodeNames: elements
+        .filter(element => element !== null)
+        .map(element => getNodeName({ sourceCode, element })),
+      contextOptions: context.options,
+    })
+  let completeOptions = complete.complete(
+    matchedContextOptions[0],
     settings,
     defaultOptions,
   )
-  let sourceCode = getSourceCode.getSourceCode(context)
+  let { type } = completeOptions
+  if (type === 'unsorted') {
+    return
+  }
+  let options = {
+    ...completeOptions,
+    type,
+  }
+  validateGeneratedGroupsConfiguration.validateGeneratedGroupsConfiguration({
+    customGroups: options.customGroups,
+    selectors: sortArrayIncludes_types.allSelectors,
+    groups: options.groups,
+    modifiers: [],
+  })
   let eslintDisabledLines = getEslintDisabledLines.getEslintDisabledLines({
     ruleName: context.id,
     sourceCode,
@@ -110,30 +161,60 @@ let sortArray = (context, messageId, elements) => {
       if (element === null) {
         return accumulator
       }
-      let lastSortingNode =
-        (_a = accumulator.at(-1)) == null ? void 0 : _a.at(-1)
+      let { defineGroup, getGroup } = useGroups.useGroups(options)
+      let groupKind
+      let selector
+      if (element.type === 'SpreadElement') {
+        groupKind = 'spread'
+        selector = 'spread'
+      } else {
+        groupKind = 'literal'
+        selector = 'literal'
+      }
+      let predefinedGroups = generatePredefinedGroups.generatePredefinedGroups({
+        cache: cachedGroupsByModifiersAndSelectors,
+        selectors: [selector],
+        modifiers: [],
+      })
+      for (let predefinedGroup of predefinedGroups) {
+        defineGroup(predefinedGroup)
+      }
+      let name = getNodeName({ sourceCode, element })
+      for (let customGroup of options.customGroups) {
+        if (
+          sortArrayIncludesUtils.customGroupMatches({
+            selectors: [selector],
+            elementName: name,
+            customGroup,
+          })
+        ) {
+          defineGroup(customGroup.groupName, true)
+          if (getGroup() === customGroup.groupName) {
+            break
+          }
+        }
+      }
       let sortingNode = {
-        name:
-          element.type === 'Literal'
-            ? `${element.value}`
-            : sourceCode.getText(element),
         isEslintDisabled: isNodeEslintDisabled.isNodeEslintDisabled(
           element,
           eslintDisabledLines,
         ),
-        groupKind: element.type === 'SpreadElement' ? 'spread' : 'literal',
         size: rangeToDiff.rangeToDiff(element, sourceCode),
+        group: getGroup(),
         node: element,
+        groupKind,
+        name,
       }
+      let lastSortingNode =
+        (_a = accumulator.at(-1)) == null ? void 0 : _a.at(-1)
       if (
-        (options.partitionByComment &&
-          isPartitionComment.hasPartitionComment(
-            options.partitionByComment,
-            getCommentsBefore.getCommentsBefore({
-              node: element,
-              sourceCode,
-            }),
-          )) ||
+        isPartitionComment.hasPartitionComment(
+          options.partitionByComment,
+          getCommentsBefore.getCommentsBefore({
+            node: element,
+            sourceCode,
+          }),
+        ) ||
         (options.partitionByNewLine &&
           lastSortingNode &&
           getLinesBetween.getLinesBetween(
@@ -166,21 +247,29 @@ let sortArray = (context, messageId, elements) => {
     )
     let sortNodesIgnoringEslintDisabledNodes = ignoreEslintDisabledNodes =>
       filteredGroupKindNodes.flatMap(groupedNodes =>
-        sortNodes.sortNodes(groupedNodes, options, {
+        sortNodesByGroups.sortNodesByGroups(groupedNodes, options, {
+          getGroupCompareOptions: groupNumber =>
+            getCustomGroupsCompareOptions.getCustomGroupsCompareOptions(
+              options,
+              groupNumber,
+            ),
           ignoreEslintDisabledNodes,
         }),
       )
     let sortedNodes = sortNodesIgnoringEslintDisabledNodes(false)
     let sortedNodesExcludingEslintDisabled =
       sortNodesIgnoringEslintDisabledNodes(true)
+    let nodeIndexMap = createNodeIndexMap.createNodeIndexMap(sortedNodes)
     pairwise.pairwise(nodes, (left, right) => {
-      let indexOfLeft = sortedNodes.indexOf(left)
-      let indexOfRight = sortedNodes.indexOf(right)
+      let leftIndex = nodeIndexMap.get(left)
+      let rightIndex = nodeIndexMap.get(right)
+      let leftNumber = getGroupNumber.getGroupNumber(options.groups, left)
+      let rightNumber = getGroupNumber.getGroupNumber(options.groups, right)
       let indexOfRightExcludingEslintDisabled =
         sortedNodesExcludingEslintDisabled.indexOf(right)
       if (
-        indexOfLeft < indexOfRight &&
-        indexOfLeft < indexOfRightExcludingEslintDisabled
+        leftIndex < rightIndex &&
+        leftIndex < indexOfRightExcludingEslintDisabled
       ) {
         return
       }
@@ -196,13 +285,20 @@ let sortArray = (context, messageId, elements) => {
         data: {
           right: toSingleLine.toSingleLine(right.name),
           left: toSingleLine.toSingleLine(left.name),
+          rightGroup: right.group,
+          leftGroup: left.group,
         },
+        messageId:
+          leftNumber === rightNumber
+            ? availableMessageIds.unexpectedOrder
+            : availableMessageIds.unexpectedGroupOrder,
         node: right.node,
-        messageId,
       })
     })
   }
 }
+let getNodeName = ({ sourceCode, element }) =>
+  element.type === 'Literal' ? `${element.value}` : sourceCode.getText(element)
 exports.default = sortArrayIncludes
 exports.defaultOptions = defaultOptions
 exports.jsonSchema = jsonSchema

package/dist/rules/sort-array-includes.types.js

@@ -0,0 +1,10 @@
+'use strict'
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' })
+const commonJsonSchemas = require('../utils/common-json-schemas.js')
+let allSelectors = ['literal', 'spread']
+let singleCustomGroupJsonSchema = {
+  selector: commonJsonSchemas.buildCustomGroupSelectorJsonSchema(allSelectors),
+  elementNamePattern: commonJsonSchemas.elementNamePatternJsonSchema,
+}
+exports.allSelectors = allSelectors
+exports.singleCustomGroupJsonSchema = singleCustomGroupJsonSchema

package/dist/rules/sort-classes.js

@@ -2,10 +2,11 @@
 const commonJsonSchemas = require('../utils/common-json-schemas.js')
 const sortNodesByDependencies = require('../utils/sort-nodes-by-dependencies.js')
 const validateNewlinesAndPartitionConfiguration = require('../utils/validate-newlines-and-partition-configuration.js')
+const validateGeneratedGroupsConfiguration = require('../utils/validate-generated-groups-configuration.js')
 const sortClasses_types = require('./sort-classes.types.js')
-const validateGeneratedGroupsConfiguration = require('./validate-generated-groups-configuration.js')
+const validateCustomSortConfiguration = require('../utils/validate-custom-sort-configuration.js')
 const sortClassesUtils = require('./sort-classes-utils.js')
-const getCustomGroupsCompareOptions = require('./get-custom-groups-compare-options.js')
+const getCustomGroupsCompareOptions = require('../utils/get-custom-groups-compare-options.js')
 const generatePredefinedGroups = require('../utils/generate-predefined-groups.js')
 const getEslintDisabledLines = require('../utils/get-eslint-disabled-lines.js')
 const isNodeEslintDisabled = require('../utils/is-node-eslint-disabled.js')
@@ -62,6 +63,7 @@ let defaultOptions = {
   ignoreCase: true,
   customGroups: [],
   locales: 'en-US',
+  alphabet: '',
   order: 'asc',
 }
 const sortClasses = createEslintRule.createEslintRule({
@@ -77,6 +79,7 @@ const sortClasses = createEslintRule.createEslintRule({
         settings,
         defaultOptions,
       )
+      validateCustomSortConfiguration.validateCustomSortConfiguration(options)
       validateGeneratedGroupsConfiguration.validateGeneratedGroupsConfiguration(
         {
           customGroups: options.customGroups,
@@ -391,14 +394,14 @@ const sortClasses = createEslintRule.createEslintRule({
             }
             selectors.push('property')
           }
-          for (let officialGroup of generatePredefinedGroups.generatePredefinedGroups(
-            {
+          let predefinedGroups =
+            generatePredefinedGroups.generatePredefinedGroups({
               cache: cachedGroupsByModifiersAndSelectors,
               selectors,
               modifiers,
-            },
-          )) {
-            defineGroup(officialGroup)
+            })
+          for (let predefinedGroup of predefinedGroups) {
+            defineGroup(predefinedGroup)
           }
           for (let customGroup of options.customGroups) {
             if (
@@ -457,14 +460,13 @@ const sortClasses = createEslintRule.createEslintRule({
                 lastMember,
                 sortingNode,
               )) ||
-            (options.partitionByComment &&
-              isPartitionComment.hasPartitionComment(
-                options.partitionByComment,
-                getCommentsBefore.getCommentsBefore({
-                  node: member,
-                  sourceCode,
-                }),
-              ))
+            isPartitionComment.hasPartitionComment(
+              options.partitionByComment,
+              getCommentsBefore.getCommentsBefore({
+                node: member,
+                sourceCode,
+              }),
+            )
           ) {
             accumulator.push([])
           }
@@ -594,10 +596,11 @@ const sortClasses = createEslintRule.createEslintRule({
           specialCharacters: commonJsonSchemas.specialCharactersJsonSchema,
           newlinesBetween: commonJsonSchemas.newlinesBetweenJsonSchema,
           ignoreCase: commonJsonSchemas.ignoreCaseJsonSchema,
+          alphabet: commonJsonSchemas.alphabetJsonSchema,
+          type: commonJsonSchemas.buildTypeJsonSchema(),
           locales: commonJsonSchemas.localesJsonSchema,
           groups: commonJsonSchemas.groupsJsonSchema,
           order: commonJsonSchemas.orderJsonSchema,
-          type: commonJsonSchemas.typeJsonSchema,
         },
         additionalProperties: false,
         type: 'object',