'use strict';




var _minimatch = require('minimatch');var _minimatch2 = _interopRequireDefault(_minimatch);
var _contextCompat = require('eslint-module-utils/contextCompat');

var _docsUrl = require('../docsUrl');var _docsUrl2 = _interopRequireDefault(_docsUrl);function _interopRequireDefault(obj) {return obj && obj.__esModule ? obj : { 'default': obj };}

/**
                                                                                                                                                                                       * @param {MemberExpression} memberExpression
                                                                                                                                                                                       * @returns {string} the name of the member in the object expression, e.g. the `x` in `namespace.x`
                                                                                                                                                                                       */
function getMemberPropertyName(memberExpression) {
  return memberExpression.property.type === 'Identifier' ?
  memberExpression.property.name :
  memberExpression.property.value;
}

/**
   * @param {ScopeManager} scopeManager
   * @param {ASTNode} node
   * @return {Set<string>}
   */ /**
       * @fileoverview Rule to disallow namespace import
       * @author Radek Benkel
       */function getVariableNamesInScope(scopeManager, node) {var currentNode = node;var scope = scopeManager.acquire(currentNode);
  while (scope == null) {
    currentNode = currentNode.parent;
    scope = scopeManager.acquire(currentNode, true);
  }
  return new Set(scope.variables.concat(scope.upper.variables).map(function (variable) {return variable.name;}));
}

/**
   *
   * @param {*} names
   * @param {*} nameConflicts
   * @param {*} namespaceName
   */
function generateLocalNames(names, nameConflicts, namespaceName) {
  var localNames = {};
  names.forEach(function (name) {
    var localName = void 0;
    if (!nameConflicts[name].has(name)) {
      localName = name;
    } else if (!nameConflicts[name].has(String(namespaceName) + '_' + String(name))) {
      localName = String(namespaceName) + '_' + String(name);
    } else {
      for (var i = 1; i < Infinity; i++) {
        if (!nameConflicts[name].has(String(namespaceName) + '_' + String(name) + '_' + String(i))) {
          localName = String(namespaceName) + '_' + String(name) + '_' + String(i);
          break;
        }
      }
    }
    localNames[name] = localName;
  });
  return localNames;
}

/**
   * @param {Identifier[]} namespaceIdentifiers
   * @returns {boolean} `true` if the namespace variable is more than just a glorified constant
   */
function usesNamespaceAsObject(namespaceIdentifiers) {
  return !namespaceIdentifiers.every(function (identifier) {
    var parent = identifier.parent;

    // `namespace.x` or `namespace['x']`
    return (
      parent &&
      parent.type === 'MemberExpression' && (
      parent.property.type === 'Identifier' || parent.property.type === 'Literal'));

  });
}

module.exports = {
  meta: {
    type: 'suggestion',
    docs: {
      category: 'Style guide',
      description: 'Forbid namespace (a.k.a. "wildcard" `*`) imports.',
      url: (0, _docsUrl2['default'])('no-namespace') },

    fixable: 'code',
    schema: [{
      type: 'object',
      properties: {
        ignore: {
          type: 'array',
          items: {
            type: 'string' },

          uniqueItems: true } } }] },





  create: function () {function create(context) {
      var firstOption = context.options[0] || {};
      var ignoreGlobs = firstOption.ignore;

      return {
        ImportNamespaceSpecifier: function () {function ImportNamespaceSpecifier(node) {
            if (ignoreGlobs && ignoreGlobs.find(function (glob) {return (0, _minimatch2['default'])(node.parent.source.value, glob, { matchBase: true });})) {
              return;
            }

            var scopeVariables = (0, _contextCompat.getScope)(context, node).variables;
            var namespaceVariable = scopeVariables.find(function (variable) {return variable.defs[0].node === node;});
            var namespaceReferences = namespaceVariable.references;
            var namespaceIdentifiers = namespaceReferences.map(function (reference) {return reference.identifier;});
            var canFix = namespaceIdentifiers.length > 0 && !usesNamespaceAsObject(namespaceIdentifiers);

            context.report({
              node: node,
              message: 'Unexpected namespace import.',
              fix: canFix && function (fixer) {var _getSourceCode =
                (0, _contextCompat.getSourceCode)(context),scopeManager = _getSourceCode.scopeManager;
                var fixes = [];

                // Pass 1: Collect variable names that are already in scope for each reference we want
                // to transform, so that we can be sure that we choose non-conflicting import names
                var importNameConflicts = {};
                namespaceIdentifiers.forEach(function (identifier) {
                  var parent = identifier.parent;
                  if (parent && parent.type === 'MemberExpression') {
                    var importName = getMemberPropertyName(parent);
                    var localConflicts = getVariableNamesInScope(scopeManager, parent);
                    if (!importNameConflicts[importName]) {
                      importNameConflicts[importName] = localConflicts;
                    } else {
                      localConflicts.forEach(function (c) {return importNameConflicts[importName].add(c);});
                    }
                  }
                });

                // Choose new names for each import
                var importNames = Object.keys(importNameConflicts);
                var importLocalNames = generateLocalNames(
                importNames,
                importNameConflicts,
                namespaceVariable.name);


                // Replace the ImportNamespaceSpecifier with a list of ImportSpecifiers
                var namedImportSpecifiers = importNames.map(function (importName) {return importName === importLocalNames[importName] ?
                  importName : String(
                  importName) + ' as ' + String(importLocalNames[importName]);});

                fixes.push(fixer.replaceText(node, '{ ' + String(namedImportSpecifiers.join(', ')) + ' }'));

                // Pass 2: Replace references to the namespace with references to the named imports
                namespaceIdentifiers.forEach(function (identifier) {
                  var parent = identifier.parent;
                  if (parent && parent.type === 'MemberExpression') {
                    var importName = getMemberPropertyName(parent);
                    fixes.push(fixer.replaceText(parent, importLocalNames[importName]));
                  }
                });

                return fixes;
              } });

          }return ImportNamespaceSpecifier;}() };

    }return create;}() };
//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/rules/no-namespace.js"],"names":["getMemberPropertyName","memberExpression","property","type","name","value","getVariableNamesInScope","scopeManager","node","currentNode","scope","acquire","parent","Set","variables","concat","upper","map","variable","generateLocalNames","names","nameConflicts","namespaceName","localNames","forEach","localName","has","i","Infinity","usesNamespaceAsObject","namespaceIdentifiers","every","identifier","module","exports","meta","docs","category","description","url","fixable","schema","properties","ignore","items","uniqueItems","create","context","firstOption","options","ignoreGlobs","ImportNamespaceSpecifier","find","glob","source","matchBase","scopeVariables","namespaceVariable","defs","namespaceReferences","references","reference","canFix","length","report","message","fix","fixer","fixes","importNameConflicts","importName","localConflicts","c","add","importNames","Object","keys","importLocalNames","namedImportSpecifiers","push","replaceText","join"],"mappings":"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","file":"no-namespace.js","sourcesContent":["/**\n * @fileoverview Rule to disallow namespace import\n * @author Radek Benkel\n */\n\nimport minimatch from 'minimatch';\nimport { getScope, getSourceCode } from 'eslint-module-utils/contextCompat';\n\nimport docsUrl from '../docsUrl';\n\n/**\n * @param {MemberExpression} memberExpression\n * @returns {string} the name of the member in the object expression, e.g. the `x` in `namespace.x`\n */\nfunction getMemberPropertyName(memberExpression) {\n  return memberExpression.property.type === 'Identifier'\n    ? memberExpression.property.name\n    : memberExpression.property.value;\n}\n\n/**\n * @param {ScopeManager} scopeManager\n * @param {ASTNode} node\n * @return {Set<string>}\n */\nfunction getVariableNamesInScope(scopeManager, node) {\n  let currentNode = node;\n  let scope = scopeManager.acquire(currentNode);\n  while (scope == null) {\n    currentNode = currentNode.parent;\n    scope = scopeManager.acquire(currentNode, true);\n  }\n  return new Set(scope.variables.concat(scope.upper.variables).map((variable) => variable.name));\n}\n\n/**\n *\n * @param {*} names\n * @param {*} nameConflicts\n * @param {*} namespaceName\n */\nfunction generateLocalNames(names, nameConflicts, namespaceName) {\n  const localNames = {};\n  names.forEach((name) => {\n    let localName;\n    if (!nameConflicts[name].has(name)) {\n      localName = name;\n    } else if (!nameConflicts[name].has(`${namespaceName}_${name}`)) {\n      localName = `${namespaceName}_${name}`;\n    } else {\n      for (let i = 1; i < Infinity; i++) {\n        if (!nameConflicts[name].has(`${namespaceName}_${name}_${i}`)) {\n          localName = `${namespaceName}_${name}_${i}`;\n          break;\n        }\n      }\n    }\n    localNames[name] = localName;\n  });\n  return localNames;\n}\n\n/**\n * @param {Identifier[]} namespaceIdentifiers\n * @returns {boolean} `true` if the namespace variable is more than just a glorified constant\n */\nfunction usesNamespaceAsObject(namespaceIdentifiers) {\n  return !namespaceIdentifiers.every((identifier) => {\n    const parent = identifier.parent;\n\n    // `namespace.x` or `namespace['x']`\n    return (\n      parent\n      && parent.type === 'MemberExpression'\n      && (parent.property.type === 'Identifier' || parent.property.type === 'Literal')\n    );\n  });\n}\n\nmodule.exports = {\n  meta: {\n    type: 'suggestion',\n    docs: {\n      category: 'Style guide',\n      description: 'Forbid namespace (a.k.a. \"wildcard\" `*`) imports.',\n      url: docsUrl('no-namespace'),\n    },\n    fixable: 'code',\n    schema: [{\n      type: 'object',\n      properties: {\n        ignore: {\n          type: 'array',\n          items: {\n            type: 'string',\n          },\n          uniqueItems: true,\n        },\n      },\n    }],\n  },\n\n  create(context) {\n    const firstOption = context.options[0] || {};\n    const ignoreGlobs = firstOption.ignore;\n\n    return {\n      ImportNamespaceSpecifier(node) {\n        if (ignoreGlobs && ignoreGlobs.find((glob) => minimatch(node.parent.source.value, glob, { matchBase: true }))) {\n          return;\n        }\n\n        const scopeVariables = getScope(context, node).variables;\n        const namespaceVariable = scopeVariables.find((variable) => variable.defs[0].node === node);\n        const namespaceReferences = namespaceVariable.references;\n        const namespaceIdentifiers = namespaceReferences.map((reference) => reference.identifier);\n        const canFix = namespaceIdentifiers.length > 0 && !usesNamespaceAsObject(namespaceIdentifiers);\n\n        context.report({\n          node,\n          message: `Unexpected namespace import.`,\n          fix: canFix && ((fixer) => {\n            const { scopeManager } = getSourceCode(context);\n            const fixes = [];\n\n            // Pass 1: Collect variable names that are already in scope for each reference we want\n            // to transform, so that we can be sure that we choose non-conflicting import names\n            const importNameConflicts = {};\n            namespaceIdentifiers.forEach((identifier) => {\n              const parent = identifier.parent;\n              if (parent && parent.type === 'MemberExpression') {\n                const importName = getMemberPropertyName(parent);\n                const localConflicts = getVariableNamesInScope(scopeManager, parent);\n                if (!importNameConflicts[importName]) {\n                  importNameConflicts[importName] = localConflicts;\n                } else {\n                  localConflicts.forEach((c) => importNameConflicts[importName].add(c));\n                }\n              }\n            });\n\n            // Choose new names for each import\n            const importNames = Object.keys(importNameConflicts);\n            const importLocalNames = generateLocalNames(\n              importNames,\n              importNameConflicts,\n              namespaceVariable.name,\n            );\n\n            // Replace the ImportNamespaceSpecifier with a list of ImportSpecifiers\n            const namedImportSpecifiers = importNames.map((importName) => importName === importLocalNames[importName]\n              ? importName\n              : `${importName} as ${importLocalNames[importName]}`,\n            );\n            fixes.push(fixer.replaceText(node, `{ ${namedImportSpecifiers.join(', ')} }`));\n\n            // Pass 2: Replace references to the namespace with references to the named imports\n            namespaceIdentifiers.forEach((identifier) => {\n              const parent = identifier.parent;\n              if (parent && parent.type === 'MemberExpression') {\n                const importName = getMemberPropertyName(parent);\n                fixes.push(fixer.replaceText(parent, importLocalNames[importName]));\n              }\n            });\n\n            return fixes;\n          }),\n        });\n      },\n    };\n  },\n};\n"]}