pundle-loader-js/lib/index.js

'use strict';

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

var _babylon = require('babylon');

var _babelTraverse = require('babel-traverse');

var _babelTraverse2 = _interopRequireDefault(_babelTraverse);

var _babelGenerator = require('babel-generator');

var _babelGenerator2 = _interopRequireDefault(_babelGenerator);

var _pundleApi = require('pundle-api');

var _helpers = require('./helpers');

var Helpers = _interopRequireWildcard(_helpers);

function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }

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

function _asyncToGenerator(fn) { return function () { var gen = fn.apply(this, arguments); return new Promise(function (resolve, reject) { function step(key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { return Promise.resolve(value).then(function (value) { step("next", value); }, function (err) { step("throw", err); }); } } return step("next"); }); }; }

var RESOLVE_NAMES = new Set(['require', 'require.ensure', 'require.resolve', 'module.hot.accept', 'module.hot.decline']);
var RESOLVE_NAMES_SENSITIVE = new Set(['require', 'require.resolve']);

exports.default = (0, _pundleApi.createLoader)(function () {
  var _ref = _asyncToGenerator(function* (context, config, file) {
    if (!(0, _pundleApi.shouldProcess)(context.config.rootDirectory, file.filePath, config)) {
      return null;
    }

    var chunks = [];
    var imports = [];

    var ast = void 0;
    try {
      ast = (0, _babylon.parse)(file.getContents(), {
        sourceType: 'module',
        sourceFilename: file.filePath,
        plugins: ['jsx', 'flow', '*']
      });
    } catch (error) {
      if (error.loc) {
        throw new _pundleApi.FileIssue(file.getFilePath(), file.getContents(), error.loc.line, error.loc.column + 1, error.message, 'error');
      } else {
        throw new _pundleApi.FileMessageIssue(file.getFilePath(), error.message);
      }
    }

    var processResolve = function processResolve(node) {
      var request = context.getImportRequest(node.value, file.filePath, node.loc);
      imports.push(request);
      node.value = request.id.toString();
    };
    var processReplaceable = function processReplaceable(path) {
      var name = Helpers.getName(path.node);
      if ({}.hasOwnProperty.call(context.config.replaceVariables, name)) {
        path.replaceWith(Helpers.getParsedReplacement(context.config.replaceVariables[name]));
      }
    };
    (0, _babelTraverse2.default)(ast, {
      ImportDeclaration: function ImportDeclaration(path) {
        processResolve(path.node.source);
      },
      CallExpression: function CallExpression(path) {
        if (path.node.callee.type === 'Import') {
          Helpers.processImport(context, file, chunks, path);
          return;
        }
        var name = Helpers.getName(path.node.callee);
        if (!RESOLVE_NAMES.has(name)) {
          return;
        }
        var parameter = path.node.arguments && path.node.arguments[0];
        if (!parameter || parameter.type !== (name === 'require.ensure' ? 'ArrayExpression' : 'StringLiteral')) {
          return;
        }
        if (RESOLVE_NAMES_SENSITIVE.has(name) && path.scope.hasBinding('require')) {
          return;
        }
        if (name === 'require.ensure') {
          Helpers.processEnsure(context, file, chunks, path);
        } else {
          processResolve(parameter);
        }
      },
      Identifier: processReplaceable,
      MemberExpression: processReplaceable
    });

    var compiled = (0, _babelGenerator2.default)(ast, {
      quotes: 'single',
      compact: true,
      comments: false,
      filename: file.filePath,
      sourceMaps: true,
      sourceFileName: file.filePath
    });

    return {
      chunks: chunks,
      imports: imports,
      contents: compiled.code,
      sourceMap: compiled.map
    };
  });

  return function (_x, _x2, _x3) {
    return _ref.apply(this, arguments);
  };
}(), {
  extensions: ['js', 'jsx']
});