babel-plugin-lodash-modularize/dist/index.js

Babel plugin that replaces lodash library import statement to individual module imports.

'use strict';

Object.defineProperty(exports, "__esModule", {
    value: true
});

var _resolveMethod = require('./resolveMethod');

var _resolveMethod2 = _interopRequireDefault(_resolveMethod);

var _semver = require('semver');

var _semver2 = _interopRequireDefault(_semver);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

var LODASH_DEFAULT_VERSION = '3.0.0';

exports.default = function (_ref) {
    var t = _ref.types;

    var importMethod = undefined,
        lodashObjects = undefined,
        lodashVersion = undefined,
        selectedMethods = undefined,
        specified = undefined;

    importMethod = function (methodName, file) {
        if (!selectedMethods[methodName]) {
            selectedMethods[methodName] = file.addImport((0, _resolveMethod2.default)(methodName), 'default', methodName);
        }

        return selectedMethods[methodName];
    };

    return {
        visitor: {
            CallExpression: function CallExpression(path) {
                var file = undefined,
                    name = undefined,
                    node = undefined;

                node = path.node;
                name = node.callee.name;
                file = path.hub.file;

                if (!t.isIdentifier(node.callee)) {
                    return;
                }

                if (specified[name]) {
                    node.callee = importMethod(specified[name], file);
                }

                if (lodashObjects[name]) {
                    throw new Error('lodash chaining syntax is not supported.');
                }
            },
            ImportDeclaration: function ImportDeclaration(path) {
                var node = undefined,
                    value = undefined;

                node = path.node;
                value = node.source.value;

                if (value !== 'lodash') {
                    return;
                }

                node.specifiers.forEach(function (specifier) {
                    if (t.isImportSpecifier(specifier)) {
                        specified[specifier.local.name] = specifier.imported.name;
                    } else {
                        lodashObjects[specifier.local.name] = true;
                    }
                });

                path.remove();
            },
            MemberExpression: function MemberExpression(path) {
                var file = undefined,
                    node = undefined;

                node = path.node;
                file = path.hub.file;

                if (!lodashObjects[node.object.name]) {
                    return;
                }

                if (node.property.name === 'chain') {
                    throw new Error('lodash chaining syntax is not supported.');
                }

                path.replaceWith(importMethod(node.property.name, file));
            },

            Program: {
                enter: function enter(path, state) {
                    lodashObjects = {};
                    specified = {};
                    selectedMethods = {};
                    lodashVersion = state.opts.lodashVersion || LODASH_DEFAULT_VERSION;

                    if (_semver2.default.lt(lodashVersion, '3.0.0')) {
                        throw new Error('lodash prior to version 3 is unsupported.');
                    }
                }
            }
        }
    };
};

module.exports = exports['default'];
//# sourceMappingURL=index.js.map