@j4cobi/eslint-plugin-sort-imports/dist/sort-imports.cjs.map

An ESLint rule that can auto fix import sorting issues.

{"version":3,"sources":["../src/sort-imports.ts"],"sourcesContent":["/**\n * @fileoverview Rule to require sorting of import declarations\n * @author Christian Schuller\n */\n\nimport { AST_NODE_TYPES, ESLintUtils, type TSESTree } from \"@typescript-eslint/utils\";\n\nconst createRule = ESLintUtils.RuleCreator((name) => name);\n\nexport enum MemberSyntaxSortOrder {\n  None = \"none\",\n  All = \"all\",\n  Multiple = \"multiple\",\n  Single = \"single\",\n}\n\nexport type Options = [\n  {\n    ignoreCase?: boolean;\n    ignoreMemberSort?: boolean;\n    memberSyntaxSortOrder?: MemberSyntaxSortOrder[];\n    typeSortStrategy?: \"mixed\" | \"before\" | \"after\";\n  },\n];\n\nconst defaultOptions: Options = [\n  {\n    ignoreCase: false,\n    ignoreMemberSort: false,\n    memberSyntaxSortOrder: [MemberSyntaxSortOrder.None, MemberSyntaxSortOrder.All, MemberSyntaxSortOrder.Multiple, MemberSyntaxSortOrder.Single],\n    typeSortStrategy: \"after\",\n  },\n];\n\nexport type MessageIds = \"memberAlphabetical\" | \"wrongOrder\" | \"typeOrder\" | \"alphabeticalOrder\";\n\nexport const rule = createRule<Options, MessageIds>({\n  name: \"eslint-sort-imports\",\n  defaultOptions,\n  meta: {\n    docs: { description: \"enforce sorted import declarations within modules\" },\n    messages: {\n      memberAlphabetical: \"Member '{{memberName}}' of the import declaration should be sorted alphabetically.\",\n      typeOrder: \"Expected type imports '{{typeSortStrategy}}' all other imports.\",\n      wrongOrder: \"Expected '{{syntaxA}}' syntax before '{{syntaxB}}' syntax.\",\n      alphabeticalOrder: \"Imports should be sorted alphabetically.\",\n    },\n    schema: [\n      {\n        type: \"object\",\n        properties: {\n          ignoreCase: { type: \"boolean\" },\n          memberSyntaxSortOrder: {\n            type: \"array\",\n            items: {\n              type: \"string\",\n              enum: [\"none\", \"all\", \"multiple\", \"single\"],\n            },\n            uniqueItems: true,\n            minItems: 4,\n            maxItems: 4,\n          },\n          typeSortStrategy: {\n            type: \"string\",\n            enum: [\"mixed\", \"before\", \"after\"],\n          },\n          ignoreMemberSort: { type: \"boolean\" },\n        },\n        additionalProperties: false,\n      },\n    ],\n    type: \"layout\",\n    fixable: \"code\",\n  },\n\n  create(context) {\n    const config = context.options[0];\n    const ignoreCase = config?.ignoreCase ?? defaultOptions[0].ignoreCase!;\n    const ignoreMemberSort = config?.ignoreMemberSort ?? defaultOptions[0].ignoreMemberSort!;\n    const memberSyntaxSortOrder = config?.memberSyntaxSortOrder ?? defaultOptions[0].memberSyntaxSortOrder!;\n    const typeSortStrategy = config?.typeSortStrategy ?? defaultOptions[0].typeSortStrategy!;\n\n    const sourceCode = context.sourceCode;\n\n    let previousDeclaration: TSESTree.ImportDeclaration | undefined = undefined;\n    let initialSource: string | undefined = undefined;\n    let allDeclarations = sourceCode.ast.body.filter((n) => n.type === \"ImportDeclaration\");\n\n    function sortAndFixAllNodes(initial: string, nodes: TSESTree.ImportDeclaration[]) {\n      const rich = nodes.map((node) => [node, initial.substring(node.range[0], node.range[1])] as const);\n      const betweens = nodes.map((node, i) => (i !== nodes.length - 1 ? initial.substring(node.range[1], nodes[i + 1].range[0]) : null)).filter((n) => n !== null);\n\n      const fixed = rich.map((n) => {\n        const node = n[0];\n\n        if (!ignoreMemberSort) {\n          const importSpecifiers = node.specifiers.filter((specifier) => specifier.type === \"ImportSpecifier\");\n          const firstUnsortedIndex = importSpecifiers.map((s) => getSortableName(s, ignoreCase)).findIndex((name, index, array) => array[index - 1] > name);\n\n          if (firstUnsortedIndex !== -1) {\n            const before = initial.substring(node.range[0], importSpecifiers[0].range[0]);\n            const after = initial.substring(importSpecifiers[importSpecifiers.length - 1].range[1], node.range[1]);\n\n            const between = importSpecifiers\n              // Clone the importSpecifiers array to avoid mutating it\n              .slice()\n              // Sort the array into the desired order\n              .sort((specifierA, specifierB) => {\n                const aName = getSortableName(specifierA, ignoreCase);\n                const bName = getSortableName(specifierB, ignoreCase);\n\n                return aName > bName ? 1 : -1;\n              })\n              // Build a string out of the sorted list of import specifiers and the text between the originals\n              .reduce((sourceText, specifier, index) => {\n                const textAfterSpecifier = index === importSpecifiers.length - 1 ? \"\" : initial.slice(importSpecifiers[index].range[1], importSpecifiers[index + 1].range[0]);\n                return sourceText + initial.substring.apply(initial, specifier.range) + textAfterSpecifier;\n              }, \"\");\n\n            return [node, `${before}${between}${after}`] as const;\n          }\n        }\n\n        return n;\n      });\n\n      // Group by ImportDeclarations that are consecutive (no lines inbetween)\n      const sections = fixed.reduce(\n        (sections, current) => {\n          const lastSection = sections[sections.length - 1];\n\n          if (lastSection.length === 0) lastSection.push(current);\n          else {\n            const lastFixed = lastSection[lastSection.length - 1];\n            if (isLineBetween(lastFixed[0], current[0])) sections.push([current]);\n            else lastSection.push(current);\n          }\n\n          return sections;\n        },\n        [[]] as (readonly [TSESTree.ImportDeclaration, string])[][],\n      );\n\n      // Sort each grouping\n      const sorted = sections\n        .map((section) =>\n          section.sort((a, b) => {\n            const currentMemberSyntaxGroupIndex = getMemberParameterGroupIndex(b[0], memberSyntaxSortOrder);\n            const currentMemberIsType = (b[0].importKind && b[0].importKind === \"type\") || false;\n            const previousMemberSyntaxGroupIndex = getMemberParameterGroupIndex(a[0], memberSyntaxSortOrder);\n            const previousMemberIsType = (a[0].importKind && a[0].importKind === \"type\") || false;\n\n            let currentLocalMemberName = getFirstLocalMemberName(b[0]);\n            let previousLocalMemberName = getFirstLocalMemberName(a[0]);\n\n            if (ignoreCase) {\n              previousLocalMemberName = previousLocalMemberName && previousLocalMemberName.toLowerCase();\n              currentLocalMemberName = currentLocalMemberName && currentLocalMemberName.toLowerCase();\n            }\n\n            if (typeSortStrategy !== \"mixed\" && currentMemberIsType !== previousMemberIsType) {\n              return (currentMemberIsType && typeSortStrategy === \"before\") || (previousMemberIsType && typeSortStrategy === \"after\") ? 1 : -1;\n            }\n            if (currentMemberSyntaxGroupIndex !== previousMemberSyntaxGroupIndex) {\n              return currentMemberSyntaxGroupIndex < previousMemberSyntaxGroupIndex ? 1 : -1;\n            } else if (previousLocalMemberName && currentLocalMemberName) {\n              return currentLocalMemberName < previousLocalMemberName ? 1 : -1;\n            }\n\n            return 0;\n          }),\n        )\n        .reduce((a, c) => a.concat(c), []); // Flatten groupings\n\n      return sorted.map((n) => n[1]).reduce((done, current, i) => `${done}${i !== 0 ? betweens[i - 1] : \"\"}${current}`, \"\");\n    }\n\n    return {\n      ImportDeclaration(node) {\n        if (!initialSource) initialSource = sourceCode.getText();\n\n        if (previousDeclaration && !isLineBetween(previousDeclaration, node)) {\n          const currentMemberSyntaxGroupIndex = getMemberParameterGroupIndex(node, memberSyntaxSortOrder);\n          const currentMemberIsType = (node.importKind && node.importKind === \"type\") || false;\n          const previousMemberSyntaxGroupIndex = getMemberParameterGroupIndex(previousDeclaration, memberSyntaxSortOrder);\n          const previousMemberIsType = (previousDeclaration.importKind && previousDeclaration.importKind === \"type\") || false;\n\n          let currentLocalMemberName = getFirstLocalMemberName(node);\n          let previousLocalMemberName = getFirstLocalMemberName(previousDeclaration);\n\n          if (ignoreCase) {\n            previousLocalMemberName = previousLocalMemberName.toLowerCase();\n            currentLocalMemberName = currentLocalMemberName.toLowerCase();\n          }\n\n          // When the current declaration uses a different member syntax,\n          // then check if the ordering is correct.\n          // Otherwise, make a default string compare (like rule sort-vars to be consistent) of the first used local member name.\n          if (typeSortStrategy !== \"mixed\" && currentMemberIsType !== previousMemberIsType) {\n            if ((currentMemberIsType && typeSortStrategy === \"before\") || (previousMemberIsType && typeSortStrategy === \"after\")) {\n              context.report({\n                node,\n                messageId: \"typeOrder\",\n                data: { typeSortStrategy },\n                fix(fixer) {\n                  return fixer.replaceTextRange(\n                    [allDeclarations[0].range[0], allDeclarations[allDeclarations.length - 1].range[1]],\n                    sortAndFixAllNodes(initialSource!, allDeclarations),\n                  );\n                },\n              });\n            }\n          } else if (currentMemberSyntaxGroupIndex !== previousMemberSyntaxGroupIndex) {\n            if (currentMemberSyntaxGroupIndex < previousMemberSyntaxGroupIndex) {\n              context.report({\n                node,\n                messageId: \"wrongOrder\",\n                data: {\n                  syntaxA: memberSyntaxSortOrder[currentMemberSyntaxGroupIndex],\n                  syntaxB: memberSyntaxSortOrder[previousMemberSyntaxGroupIndex],\n                },\n                fix(fixer) {\n                  return fixer.replaceTextRange(\n                    [allDeclarations[0].range[0], allDeclarations[allDeclarations.length - 1].range[1]],\n                    sortAndFixAllNodes(initialSource!, allDeclarations),\n                  );\n                },\n              });\n            }\n          } else {\n            if (previousLocalMemberName && currentLocalMemberName && currentLocalMemberName < previousLocalMemberName) {\n              context.report({\n                node,\n                messageId: \"alphabeticalOrder\",\n                fix(fixer) {\n                  return fixer.replaceTextRange(\n                    [allDeclarations[0].range[0], allDeclarations[allDeclarations.length - 1].range[1]],\n                    sortAndFixAllNodes(initialSource!, allDeclarations),\n                  );\n                },\n              });\n            }\n          }\n        }\n\n        // Multiple members of an import declaration should also be sorted alphabetically.\n\n        if (!ignoreMemberSort) {\n          const importSpecifiers = node.specifiers.filter((specifier) => specifier.type === AST_NODE_TYPES.ImportSpecifier);\n\n          const firstUnsortedIndex = importSpecifiers.map((s) => getSortableName(s, ignoreCase)).findIndex((name, index, array) => array[index - 1] > name);\n\n          if (firstUnsortedIndex !== -1) {\n            context.report({\n              node: importSpecifiers[firstUnsortedIndex],\n              messageId: \"memberAlphabetical\",\n              data: {\n                memberName: importSpecifiers[firstUnsortedIndex].local.name,\n              },\n              fix(fixer) {\n                const hasComments = importSpecifiers.some((specifier) => sourceCode.getCommentsBefore(specifier).length || sourceCode.getCommentsAfter(specifier).length);\n\n                // If there are comments in the ImportSpecifier list, don't rearrange the specifiers.\n                if (hasComments) return null;\n\n                return fixer.replaceTextRange(\n                  [allDeclarations[0].range[0], allDeclarations[allDeclarations.length - 1].range[1]],\n                  sortAndFixAllNodes(initialSource!, allDeclarations),\n                );\n              },\n            });\n          }\n        }\n\n        previousDeclaration = node;\n      },\n    };\n  },\n});\n\nfunction getSortableName(specifier: TSESTree.ImportSpecifier, ignoreCase: boolean) {\n  if (ignoreCase) return specifier.local.name.toLowerCase();\n  return specifier.local.name;\n}\n\n/**\n * Gets the used member syntax style.\n *\n * import \"my-module.js\" --> none\n * import * as myModule from \"my-module.js\" --> all\n * import {myMember} from \"my-module.js\" --> single\n * import {foo, bar} from  \"my-module.js\" --> multiple\n *\n */\nfunction usedMemberSyntax(node: TSESTree.ImportDeclaration): MemberSyntaxSortOrder {\n  switch (node.specifiers[0]?.type) {\n    case AST_NODE_TYPES.ImportNamespaceSpecifier:\n      return MemberSyntaxSortOrder.All;\n    case AST_NODE_TYPES.ImportDefaultSpecifier:\n      return MemberSyntaxSortOrder.Single;\n    case AST_NODE_TYPES.ImportSpecifier:\n      return MemberSyntaxSortOrder.Multiple;\n    default:\n      return MemberSyntaxSortOrder.None;\n  }\n}\n\n/**\n * Gets the group by member parameter index for given declaration.\n * @param {ASTNode} node - the ImportDeclaration node.\n * @returns {number} the declaration group by member index.\n */\nfunction getMemberParameterGroupIndex(node: TSESTree.ImportDeclaration, memberSyntaxSortOrder: MemberSyntaxSortOrder[]) {\n  return memberSyntaxSortOrder.indexOf(usedMemberSyntax(node));\n}\n\n/**\n * Gets the local name of the first imported module.\n * @param {ASTNode} node - the ImportDeclaration node.\n * @returns {?string} the local name of the first imported module.\n */\nfunction getFirstLocalMemberName(node: TSESTree.ImportDeclaration) {\n  return node.specifiers.length ? node.specifiers[0].local.name : node.source.value;\n}\n\n/**\n * Gets if there are lines (empty or comments) between two nodes\n * @param {ASTNode} firstNode - the ImportDeclaration node.\n * @param {ASTNode} secondNode - the ImportDeclaration node.\n * @returns {boolean} if there are lines between the nodes.\n */\nfunction isLineBetween(firstNode: TSESTree.ImportDeclaration, secondNode: TSESTree.ImportDeclaration) {\n  return firstNode.loc.end.line < secondNode.loc.start.line - 1;\n}\n"],"mappings":"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","names":["MemberSyntaxSortOrder","sections"]}