eslint-plugin-i/lib/rules/order.js

A fork of `eslint-plugin-import` using `get-tsconfig` to replace `tsconfig-paths` and heavy `typescript` under the hood.

'use strict';var _slicedToArray = function () {function sliceIterator(arr, i) {var _arr = [];var _n = true;var _d = false;var _e = undefined;try {for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) {_arr.push(_s.value);if (i && _arr.length === i) break;}} catch (err) {_d = true;_e = err;} finally {try {if (!_n && _i["return"]) _i["return"]();} finally {if (_d) throw _e;}}return _arr;}return function (arr, i) {if (Array.isArray(arr)) {return arr;} else if (Symbol.iterator in Object(arr)) {return sliceIterator(arr, i);} else {throw new TypeError("Invalid attempt to destructure non-iterable instance");}};}();

var _minimatch = require('minimatch');var _minimatch2 = _interopRequireDefault(_minimatch);

var _importType = require('../core/importType');var _importType2 = _interopRequireDefault(_importType);
var _staticRequire = require('../core/staticRequire');var _staticRequire2 = _interopRequireDefault(_staticRequire);
var _docsUrl = require('../docsUrl');var _docsUrl2 = _interopRequireDefault(_docsUrl);function _interopRequireDefault(obj) {return obj && obj.__esModule ? obj : { 'default': obj };}

var includes = Function.bind.bind(Function.prototype.call)(Array.prototype.includes);
// This is a **non-spec compliant** but works in practice replacement of `object.groupby` package.
var groupBy = function groupBy(array, grouper) {return array.reduce(function (acc, curr, index) {
    var key = grouper(curr, index);
    (acc[key] = acc[key] || []).push(curr);
    return acc;
  }, {});};

var defaultGroups = ['builtin', 'external', 'parent', 'sibling', 'index'];

// REPORTING AND FIXING

function reverse(array) {
  return array.map(function (v) {
    return Object.assign({}, v, { rank: -v.rank });
  }).reverse();
}

function getTokensOrCommentsAfter(sourceCode, node, count) {
  var currentNodeOrToken = node;
  var result = [];
  for (var i = 0; i < count; i++) {
    currentNodeOrToken = sourceCode.getTokenOrCommentAfter(currentNodeOrToken);
    if (currentNodeOrToken == null) {
      break;
    }
    result.push(currentNodeOrToken);
  }
  return result;
}

function getTokensOrCommentsBefore(sourceCode, node, count) {
  var currentNodeOrToken = node;
  var result = [];
  for (var i = 0; i < count; i++) {
    currentNodeOrToken = sourceCode.getTokenOrCommentBefore(currentNodeOrToken);
    if (currentNodeOrToken == null) {
      break;
    }
    result.push(currentNodeOrToken);
  }
  return result.reverse();
}

function takeTokensAfterWhile(sourceCode, node, condition) {
  var tokens = getTokensOrCommentsAfter(sourceCode, node, 100);
  var result = [];
  for (var i = 0; i < tokens.length; i++) {
    if (condition(tokens[i])) {
      result.push(tokens[i]);
    } else {
      break;
    }
  }
  return result;
}

function takeTokensBeforeWhile(sourceCode, node, condition) {
  var tokens = getTokensOrCommentsBefore(sourceCode, node, 100);
  var result = [];
  for (var i = tokens.length - 1; i >= 0; i--) {
    if (condition(tokens[i])) {
      result.push(tokens[i]);
    } else {
      break;
    }
  }
  return result.reverse();
}

function findOutOfOrder(imported) {
  if (imported.length === 0) {
    return [];
  }
  var maxSeenRankNode = imported[0];
  return imported.filter(function (importedModule) {
    var res = importedModule.rank < maxSeenRankNode.rank;
    if (maxSeenRankNode.rank < importedModule.rank) {
      maxSeenRankNode = importedModule;
    }
    return res;
  });
}

function findRootNode(node) {
  var parent = node;
  while (parent.parent != null && parent.parent.body == null) {
    parent = parent.parent;
  }
  return parent;
}

function findEndOfLineWithComments(sourceCode, node) {
  var tokensToEndOfLine = takeTokensAfterWhile(sourceCode, node, commentOnSameLineAs(node));
  var endOfTokens = tokensToEndOfLine.length > 0 ?
  tokensToEndOfLine[tokensToEndOfLine.length - 1].range[1] :
  node.range[1];
  var result = endOfTokens;
  for (var i = endOfTokens; i < sourceCode.text.length; i++) {
    if (sourceCode.text[i] === '\n') {
      result = i + 1;
      break;
    }
    if (sourceCode.text[i] !== ' ' && sourceCode.text[i] !== '\t' && sourceCode.text[i] !== '\r') {
      break;
    }
    result = i + 1;
  }
  return result;
}

function commentOnSameLineAs(node) {
  return function (token) {return (token.type === 'Block' || token.type === 'Line') &&
    token.loc.start.line === token.loc.end.line &&
    token.loc.end.line === node.loc.end.line;};
}

function findStartOfLineWithComments(sourceCode, node) {
  var tokensToEndOfLine = takeTokensBeforeWhile(sourceCode, node, commentOnSameLineAs(node));
  var startOfTokens = tokensToEndOfLine.length > 0 ? tokensToEndOfLine[0].range[0] : node.range[0];
  var result = startOfTokens;
  for (var i = startOfTokens - 1; i > 0; i--) {
    if (sourceCode.text[i] !== ' ' && sourceCode.text[i] !== '\t') {
      break;
    }
    result = i;
  }
  return result;
}

function isRequireExpression(expr) {
  return expr != null &&
  expr.type === 'CallExpression' &&
  expr.callee != null &&
  expr.callee.name === 'require' &&
  expr.arguments != null &&
  expr.arguments.length === 1 &&
  expr.arguments[0].type === 'Literal';
}

function isSupportedRequireModule(node) {
  if (node.type !== 'VariableDeclaration') {
    return false;
  }
  if (node.declarations.length !== 1) {
    return false;
  }
  var decl = node.declarations[0];
  var isPlainRequire = decl.id && (
  decl.id.type === 'Identifier' || decl.id.type === 'ObjectPattern') &&
  isRequireExpression(decl.init);
  var isRequireWithMemberExpression = decl.id && (
  decl.id.type === 'Identifier' || decl.id.type === 'ObjectPattern') &&
  decl.init != null &&
  decl.init.type === 'CallExpression' &&
  decl.init.callee != null &&
  decl.init.callee.type === 'MemberExpression' &&
  isRequireExpression(decl.init.callee.object);
  return isPlainRequire || isRequireWithMemberExpression;
}

function isPlainImportModule(node) {
  return node.type === 'ImportDeclaration' && node.specifiers != null && node.specifiers.length > 0;
}

function isPlainImportEquals(node) {
  return node.type === 'TSImportEqualsDeclaration' && node.moduleReference.expression;
}

function canCrossNodeWhileReorder(node) {
  return isSupportedRequireModule(node) || isPlainImportModule(node) || isPlainImportEquals(node);
}

function canReorderItems(firstNode, secondNode) {
  var parent = firstNode.parent;var _sort =
  [
  parent.body.indexOf(firstNode),
  parent.body.indexOf(secondNode)].
  sort(),_sort2 = _slicedToArray(_sort, 2),firstIndex = _sort2[0],secondIndex = _sort2[1];
  var nodesBetween = parent.body.slice(firstIndex, secondIndex + 1);var _iteratorNormalCompletion = true;var _didIteratorError = false;var _iteratorError = undefined;try {
    for (var _iterator = nodesBetween[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {var nodeBetween = _step.value;
      if (!canCrossNodeWhileReorder(nodeBetween)) {
        return false;
      }
    }} catch (err) {_didIteratorError = true;_iteratorError = err;} finally {try {if (!_iteratorNormalCompletion && _iterator['return']) {_iterator['return']();}} finally {if (_didIteratorError) {throw _iteratorError;}}}
  return true;
}

function makeImportDescription(node) {
  if (node.node.importKind === 'type') {
    return 'type import';
  }
  if (node.node.importKind === 'typeof') {
    return 'typeof import';
  }
  return 'import';
}

function fixOutOfOrder(context, firstNode, secondNode, order) {
  var sourceCode = context.getSourceCode();

  var firstRoot = findRootNode(firstNode.node);
  var firstRootStart = findStartOfLineWithComments(sourceCode, firstRoot);
  var firstRootEnd = findEndOfLineWithComments(sourceCode, firstRoot);

  var secondRoot = findRootNode(secondNode.node);
  var secondRootStart = findStartOfLineWithComments(sourceCode, secondRoot);
  var secondRootEnd = findEndOfLineWithComments(sourceCode, secondRoot);
  var canFix = canReorderItems(firstRoot, secondRoot);

  var newCode = sourceCode.text.substring(secondRootStart, secondRootEnd);
  if (newCode[newCode.length - 1] !== '\n') {
    newCode = String(newCode) + '\n';
  }

  var firstImport = String(makeImportDescription(firstNode)) + ' of `' + String(firstNode.displayName) + '`';
  var secondImport = '`' + String(secondNode.displayName) + '` ' + String(makeImportDescription(secondNode));
  var message = secondImport + ' should occur ' + String(order) + ' ' + firstImport;

  if (order === 'before') {
    context.report({
      node: secondNode.node,
      message: message,
      fix: canFix && function (fixer) {return fixer.replaceTextRange(
        [firstRootStart, secondRootEnd],
        newCode + sourceCode.text.substring(firstRootStart, secondRootStart));} });


  } else if (order === 'after') {
    context.report({
      node: secondNode.node,
      message: message,
      fix: canFix && function (fixer) {return fixer.replaceTextRange(
        [secondRootStart, firstRootEnd],
        sourceCode.text.substring(secondRootEnd, firstRootEnd) + newCode);} });


  }
}

function reportOutOfOrder(context, imported, outOfOrder, order) {
  outOfOrder.forEach(function (imp) {
    var found = imported.find(function () {function hasHigherRank(importedItem) {
        return importedItem.rank > imp.rank;
      }return hasHigherRank;}());
    fixOutOfOrder(context, found, imp, order);
  });
}

function makeOutOfOrderReport(context, imported) {
  var outOfOrder = findOutOfOrder(imported);
  if (!outOfOrder.length) {
    return;
  }

  // There are things to report. Try to minimize the number of reported errors.
  var reversedImported = reverse(imported);
  var reversedOrder = findOutOfOrder(reversedImported);
  if (reversedOrder.length < outOfOrder.length) {
    reportOutOfOrder(context, reversedImported, reversedOrder, 'after');
    return;
  }
  reportOutOfOrder(context, imported, outOfOrder, 'before');
}

var compareString = function compareString(a, b) {
  if (a < b) {
    return -1;
  }
  if (a > b) {
    return 1;
  }
  return 0;
};

/** Some parsers (languages without types) don't provide ImportKind */
var DEAFULT_IMPORT_KIND = 'value';
var getNormalizedValue = function getNormalizedValue(node, toLowerCase) {
  var value = node.value;
  return toLowerCase ? String(value).toLowerCase() : value;
};

function getSorter(alphabetizeOptions) {
  var multiplier = alphabetizeOptions.order === 'asc' ? 1 : -1;
  var orderImportKind = alphabetizeOptions.orderImportKind;
  var multiplierImportKind = orderImportKind !== 'ignore' && (
  alphabetizeOptions.orderImportKind === 'asc' ? 1 : -1);

  return function () {function importsSorter(nodeA, nodeB) {
      var importA = getNormalizedValue(nodeA, alphabetizeOptions.caseInsensitive);
      var importB = getNormalizedValue(nodeB, alphabetizeOptions.caseInsensitive);
      var result = 0;

      if (!includes(importA, '/') && !includes(importB, '/')) {
        result = compareString(importA, importB);
      } else {
        var A = importA.split('/');
        var B = importB.split('/');
        var a = A.length;
        var b = B.length;

        for (var i = 0; i < Math.min(a, b); i++) {
          result = compareString(A[i], B[i]);
          if (result) {break;}
        }

        if (!result && a !== b) {
          result = a < b ? -1 : 1;
        }
      }

      result = result * multiplier;

      // In case the paths are equal (result === 0), sort them by importKind
      if (!result && multiplierImportKind) {
        result = multiplierImportKind * compareString(
        nodeA.node.importKind || DEAFULT_IMPORT_KIND,
        nodeB.node.importKind || DEAFULT_IMPORT_KIND);

      }

      return result;
    }return importsSorter;}();
}

function mutateRanksToAlphabetize(imported, alphabetizeOptions) {
  var groupedByRanks = groupBy(imported, function (item) {return item.rank;});

  var sorterFn = getSorter(alphabetizeOptions);

  // sort group keys so that they can be iterated on in order
  var groupRanks = Object.keys(groupedByRanks).sort(function (a, b) {
    return a - b;
  });

  // sort imports locally within their group
  groupRanks.forEach(function (groupRank) {
    groupedByRanks[groupRank].sort(sorterFn);
  });

  // assign globally unique rank to each import
  var newRank = 0;
  var alphabetizedRanks = groupRanks.reduce(function (acc, groupRank) {
    groupedByRanks[groupRank].forEach(function (importedItem) {
      acc[String(importedItem.value) + '|' + String(importedItem.node.importKind)] = parseInt(groupRank, 10) + newRank;
      newRank += 1;
    });
    return acc;
  }, {});

  // mutate the original group-rank with alphabetized-rank
  imported.forEach(function (importedItem) {
    importedItem.rank = alphabetizedRanks[String(importedItem.value) + '|' + String(importedItem.node.importKind)];
  });
}

// DETECTING

function computePathRank(ranks, pathGroups, path, maxPosition) {
  for (var i = 0, l = pathGroups.length; i < l; i++) {var _pathGroups$i =
    pathGroups[i],pattern = _pathGroups$i.pattern,patternOptions = _pathGroups$i.patternOptions,group = _pathGroups$i.group,_pathGroups$i$positio = _pathGroups$i.position,position = _pathGroups$i$positio === undefined ? 1 : _pathGroups$i$positio;
    if ((0, _minimatch2['default'])(path, pattern, patternOptions || { nocomment: true })) {
      return ranks[group] + position / maxPosition;
    }
  }
}

function computeRank(context, ranks, importEntry, excludedImportTypes) {
  var impType = void 0;
  var rank = void 0;
  if (importEntry.type === 'import:object') {
    impType = 'object';
  } else if (importEntry.node.importKind === 'type' && ranks.omittedTypes.indexOf('type') === -1) {
    impType = 'type';
  } else {
    impType = (0, _importType2['default'])(importEntry.value, context);
  }
  if (!excludedImportTypes.has(impType)) {
    rank = computePathRank(ranks.groups, ranks.pathGroups, importEntry.value, ranks.maxPosition);
  }
  if (typeof rank === 'undefined') {
    rank = ranks.groups[impType];
  }
  if (importEntry.type !== 'import' && !importEntry.type.startsWith('import:')) {
    rank += 100;
  }

  return rank;
}

function registerNode(context, importEntry, ranks, imported, excludedImportTypes) {
  var rank = computeRank(context, ranks, importEntry, excludedImportTypes);
  if (rank !== -1) {
    imported.push(Object.assign({}, importEntry, { rank: rank }));
  }
}

function getRequireBlock(node) {
  var n = node;
  // Handle cases like `const baz = require('foo').bar.baz`
  // and `const foo = require('foo')()`
  while (
  n.parent.type === 'MemberExpression' && n.parent.object === n ||
  n.parent.type === 'CallExpression' && n.parent.callee === n)
  {
    n = n.parent;
  }
  if (
  n.parent.type === 'VariableDeclarator' &&
  n.parent.parent.type === 'VariableDeclaration' &&
  n.parent.parent.parent.type === 'Program')
  {
    return n.parent.parent.parent;
  }
}

var types = ['builtin', 'external', 'internal', 'unknown', 'parent', 'sibling', 'index', 'object', 'type'];

// Creates an object with type-rank pairs.
// Example: { index: 0, sibling: 1, parent: 1, external: 1, builtin: 2, internal: 2 }
// Will throw an error if it contains a type that does not exist, or has a duplicate
function convertGroupsToRanks(groups) {
  var rankObject = groups.reduce(function (res, group, index) {
    [].concat(group).forEach(function (groupItem) {
      if (types.indexOf(groupItem) === -1) {
        throw new Error('Incorrect configuration of the rule: Unknown type `' + String(JSON.stringify(groupItem)) + '`');
      }
      if (res[groupItem] !== undefined) {
        throw new Error('Incorrect configuration of the rule: `' + String(groupItem) + '` is duplicated');
      }
      res[groupItem] = index * 2;
    });
    return res;
  }, {});

  var omittedTypes = types.filter(function (type) {
    return typeof rankObject[type] === 'undefined';
  });

  var ranks = omittedTypes.reduce(function (res, type) {
    res[type] = groups.length * 2;
    return res;
  }, rankObject);

  return { groups: ranks, omittedTypes: omittedTypes };
}

function convertPathGroupsForRanks(pathGroups) {
  var after = {};
  var before = {};

  var transformed = pathGroups.map(function (pathGroup, index) {var
    group = pathGroup.group,positionString = pathGroup.position;
    var position = 0;
    if (positionString === 'after') {
      if (!after[group]) {
        after[group] = 1;
      }
      position = after[group]++;
    } else if (positionString === 'before') {
      if (!before[group]) {
        before[group] = [];
      }
      before[group].push(index);
    }

    return Object.assign({}, pathGroup, { position: position });
  });

  var maxPosition = 1;

  Object.keys(before).forEach(function (group) {
    var groupLength = before[group].length;
    before[group].forEach(function (groupIndex, index) {
      transformed[groupIndex].position = -1 * (groupLength - index);
    });
    maxPosition = Math.max(maxPosition, groupLength);
  });

  Object.keys(after).forEach(function (key) {
    var groupNextPosition = after[key];
    maxPosition = Math.max(maxPosition, groupNextPosition - 1);
  });

  return {
    pathGroups: transformed,
    maxPosition: maxPosition > 10 ? Math.pow(10, Math.ceil(Math.log10(maxPosition))) : 10 };

}

function fixNewLineAfterImport(context, previousImport) {
  var prevRoot = findRootNode(previousImport.node);
  var tokensToEndOfLine = takeTokensAfterWhile(
  context.getSourceCode(), prevRoot, commentOnSameLineAs(prevRoot));

  var endOfLine = prevRoot.range[1];
  if (tokensToEndOfLine.length > 0) {
    endOfLine = tokensToEndOfLine[tokensToEndOfLine.length - 1].range[1];
  }
  return function (fixer) {return fixer.insertTextAfterRange([prevRoot.range[0], endOfLine], '\n');};
}

function removeNewLineAfterImport(context, currentImport, previousImport) {
  var sourceCode = context.getSourceCode();
  var prevRoot = findRootNode(previousImport.node);
  var currRoot = findRootNode(currentImport.node);
  var rangeToRemove = [
  findEndOfLineWithComments(sourceCode, prevRoot),
  findStartOfLineWithComments(sourceCode, currRoot)];

  if (/^\s*$/.test(sourceCode.text.substring(rangeToRemove[0], rangeToRemove[1]))) {
    return function (fixer) {return fixer.removeRange(rangeToRemove);};
  }
  return undefined;
}

function makeNewlinesBetweenReport(context, imported, newlinesBetweenImports, distinctGroup) {
  var getNumberOfEmptyLinesBetween = function getNumberOfEmptyLinesBetween(currentImport, previousImport) {
    var linesBetweenImports = context.getSourceCode().lines.slice(
    previousImport.node.loc.end.line,
    currentImport.node.loc.start.line - 1);


    return linesBetweenImports.filter(function (line) {return !line.trim().length;}).length;
  };
  var getIsStartOfDistinctGroup = function getIsStartOfDistinctGroup(currentImport, previousImport) {return currentImport.rank - 1 >= previousImport.rank;};
  var previousImport = imported[0];

  imported.slice(1).forEach(function (currentImport) {
    var emptyLinesBetween = getNumberOfEmptyLinesBetween(currentImport, previousImport);
    var isStartOfDistinctGroup = getIsStartOfDistinctGroup(currentImport, previousImport);

    if (newlinesBetweenImports === 'always' ||
    newlinesBetweenImports === 'always-and-inside-groups') {
      if (currentImport.rank !== previousImport.rank && emptyLinesBetween === 0) {
        if (distinctGroup || !distinctGroup && isStartOfDistinctGroup) {
          context.report({
            node: previousImport.node,
            message: 'There should be at least one empty line between import groups',
            fix: fixNewLineAfterImport(context, previousImport) });

        }
      } else if (emptyLinesBetween > 0 &&
      newlinesBetweenImports !== 'always-and-inside-groups') {
        if (distinctGroup && currentImport.rank === previousImport.rank || !distinctGroup && !isStartOfDistinctGroup) {
          context.report({
            node: previousImport.node,
            message: 'There should be no empty line within import group',
            fix: removeNewLineAfterImport(context, currentImport, previousImport) });

        }
      }
    } else if (emptyLinesBetween > 0) {
      context.report({
        node: previousImport.node,
        message: 'There should be no empty line between import groups',
        fix: removeNewLineAfterImport(context, currentImport, previousImport) });

    }

    previousImport = currentImport;
  });
}

function getAlphabetizeConfig(options) {
  var alphabetize = options.alphabetize || {};
  var order = alphabetize.order || 'ignore';
  var orderImportKind = alphabetize.orderImportKind || 'ignore';
  var caseInsensitive = alphabetize.caseInsensitive || false;

  return { order: order, orderImportKind: orderImportKind, caseInsensitive: caseInsensitive };
}

// TODO, semver-major: Change the default of "distinctGroup" from true to false
var defaultDistinctGroup = true;

module.exports = {
  meta: {
    type: 'suggestion',
    docs: {
      category: 'Style guide',
      description: 'Enforce a convention in module import order.',
      url: (0, _docsUrl2['default'])('order') },


    fixable: 'code',
    schema: [
    {
      type: 'object',
      properties: {
        groups: {
          type: 'array' },

        pathGroupsExcludedImportTypes: {
          type: 'array' },

        distinctGroup: {
          type: 'boolean',
          'default': defaultDistinctGroup },

        pathGroups: {
          type: 'array',
          items: {
            type: 'object',
            properties: {
              pattern: {
                type: 'string' },

              patternOptions: {
                type: 'object' },

              group: {
                type: 'string',
                'enum': types },

              position: {
                type: 'string',
                'enum': ['after', 'before'] } },


            additionalProperties: false,
            required: ['pattern', 'group'] } },


        'newlines-between': {
          'enum': [
          'ignore',
          'always',
          'always-and-inside-groups',
          'never'] },


        alphabetize: {
          type: 'object',
          properties: {
            caseInsensitive: {
              type: 'boolean',
              'default': false },

            order: {
              'enum': ['ignore', 'asc', 'desc'],
              'default': 'ignore' },

            orderImportKind: {
              'enum': ['ignore', 'asc', 'desc'],
              'default': 'ignore' } },


          additionalProperties: false },

        warnOnUnassignedImports: {
          type: 'boolean',
          'default': false } },


      additionalProperties: false }] },




  create: function () {function importOrderRule(context) {
      var options = context.options[0] || {};
      var newlinesBetweenImports = options['newlines-between'] || 'ignore';
      var pathGroupsExcludedImportTypes = new Set(options.pathGroupsExcludedImportTypes || ['builtin', 'external', 'object']);
      var alphabetize = getAlphabetizeConfig(options);
      var distinctGroup = options.distinctGroup == null ? defaultDistinctGroup : !!options.distinctGroup;
      var ranks = void 0;

      try {var _convertPathGroupsFor =
        convertPathGroupsForRanks(options.pathGroups || []),pathGroups = _convertPathGroupsFor.pathGroups,maxPosition = _convertPathGroupsFor.maxPosition;var _convertGroupsToRanks =
        convertGroupsToRanks(options.groups || defaultGroups),groups = _convertGroupsToRanks.groups,omittedTypes = _convertGroupsToRanks.omittedTypes;
        ranks = {
          groups: groups,
          omittedTypes: omittedTypes,
          pathGroups: pathGroups,
          maxPosition: maxPosition };

      } catch (error) {
        // Malformed configuration
        return {
          Program: function () {function Program(node) {
              context.report(node, error.message);
            }return Program;}() };

      }
      var importMap = new Map();

      function getBlockImports(node) {
        if (!importMap.has(node)) {
          importMap.set(node, []);
        }
        return importMap.get(node);
      }

      return {
        ImportDeclaration: function () {function handleImports(node) {
            // Ignoring unassigned imports unless warnOnUnassignedImports is set
            if (node.specifiers.length || options.warnOnUnassignedImports) {
              var name = node.source.value;
              registerNode(
              context,
              {
                node: node,
                value: name,
                displayName: name,
                type: 'import' },

              ranks,
              getBlockImports(node.parent),
              pathGroupsExcludedImportTypes);

            }
          }return handleImports;}(),
        TSImportEqualsDeclaration: function () {function handleImports(node) {
            var displayName = void 0;
            var value = void 0;
            var type = void 0;
            // skip "export import"s
            if (node.isExport) {
              return;
            }
            if (node.moduleReference.type === 'TSExternalModuleReference') {
              value = node.moduleReference.expression.value;
              displayName = value;
              type = 'import';
            } else {
              value = '';
              displayName = context.getSourceCode().getText(node.moduleReference);
              type = 'import:object';
            }
            registerNode(
            context,
            {
              node: node,
              value: value,
              displayName: displayName,
              type: type },

            ranks,
            getBlockImports(node.parent),
            pathGroupsExcludedImportTypes);

          }return handleImports;}(),
        CallExpression: function () {function handleRequires(node) {
            if (!(0, _staticRequire2['default'])(node)) {
              return;
            }
            var block = getRequireBlock(node);
            if (!block) {
              return;
            }
            var name = node.arguments[0].value;
            registerNode(
            context,
            {
              node: node,
              value: name,
              displayName: name,
              type: 'require' },

            ranks,
            getBlockImports(block),
            pathGroupsExcludedImportTypes);

          }return handleRequires;}(),
        'Program:exit': function () {function reportAndReset() {
            importMap.forEach(function (imported) {
              if (newlinesBetweenImports !== 'ignore') {
                makeNewlinesBetweenReport(context, imported, newlinesBetweenImports, distinctGroup);
              }

              if (alphabetize.order !== 'ignore') {
                mutateRanksToAlphabetize(imported, alphabetize);
              }

              makeOutOfOrderReport(context, imported);
            });

            importMap.clear();
          }return reportAndReset;}() };

    }return importOrderRule;}() };
//# sourceMappingURL=data:application/json;charset=utf-8;base64,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