babel-plugin-transform-me-module/lib/index.js

Transform me.js module to commonjs module

"use strict";

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

var _path = require("path");

var _lodash = require("lodash");

var _parser = require("@babel/parser");

var _meModuleUtils = require("me-module-utils");

var _pathDetector = require("./pathDetector");

var _codeGenerator = require("./codeGenerator");

var _pathModifier = require("./pathModifier");

function transformMeModulePlugin({
  types: t
}) {
  return {
    pre(state) {
      this._filename = state.opts.filename;
      this._absolutePath = (0, _path.resolve)(this._filename);

      if (state.opts.enableDebug) {
        console.log('Parsing...', this._absolutePath);
      }
    },

    visitor: {
      Program: {
        exit(path, state) {
          const basePath = (0, _path.resolve)(state.opts.basePath);
          const meModules = getGlobalMeModuleInstance({
            basePath,
            enableDebug: state.opts.enableDebug
          });
          const curModule = meModules.get({
            src: this._absolutePath
          });

          if (!curModule) {
            return;
          } // 在头部中插入解构依赖模块


          (0, _lodash.each)(curModule.deps, (dep, name) => {
            const mod = meModules.get({
              name
            });
            const depAbsolutePath = mod.absolutePath;
            const requireRelativePath = (0, _meModuleUtils.relativeRequirePath)(this._absolutePath, depAbsolutePath);
            const requireNode = (0, _parser.parse)((0, _codeGenerator.generateModuleRequire)(mod.varName, requireRelativePath)).program.body[0];
            (0, _pathModifier.unshiftHeader)(path, requireNode);
          }); // 插入css

          (0, _lodash.each)(curModule.css, cssPath => {
            const cssRelativePath = (0, _meModuleUtils.relativeRequirePath)(this._absolutePath, cssPath);
            const requireNode = (0, _parser.parse)((0, _codeGenerator.generateRequireCss)(cssRelativePath)).program.body[0];
            (0, _pathModifier.unshiftHeader)(path, requireNode);
          });
        }

      },
      CallExpression: {
        enter(path) {
          const node = path.node;

          if ((0, _pathDetector.isEvalFunctionCall)(node)) {
            return path.remove();
          }

          if ((0, _pathDetector.isProvideFunctionCall)(node) || (0, _pathDetector.isReadyFunctionCall)(node)) {
            let meCallbackFn = null;
            let i = -1;

            while (i++ < path.node.arguments.length) {
              const curNode = path.node.arguments[i];

              if (t.isFunctionExpression(curNode)) {
                meCallbackFn = curNode;
                break;
              }
            }

            if (meCallbackFn) {
              meCallbackFn.params = [];
              path.replaceWith(t.callExpression(meCallbackFn, []));
            }
          }
        }

      },

      Identifier(path, state) {
        const basePath = (0, _path.resolve)(state.opts.basePath);
        const meModules = getGlobalMeModuleInstance({
          basePath,
          enableDebug: state.opts.enableDebug
        });
        const curModule = meModules.get({
          src: this._absolutePath
        });

        if (!curModule || !curModule.isMeModule) {
          return;
        }

        if (path.node.name === 'exports') {
          if (path.parentPath.node.property) {
            const exportsVar = path.parentPath.node.property.name;
            const depName = findDep(exportsVar, curModule.deps);

            if (!curModule.selfExports.includes(exportsVar) && depName) {
              path.node.name = `${depName}_module`;
            }
          }
        }
      }

    }
  };
}

function getGlobalMeModuleInstance(options) {
  global.meModules = (0, _meModuleUtils.getMeModuleInstance)(options);
  return global.meModules;
}
/**
 * 搜索某个变量属于那个模块
 *
 * @param {string} exportName 输出变量名
 * @param {Object} deps 依赖关系
 * @returns {string}
 */


function findDep(exportName, deps) {
  return (0, _lodash.findKey)(deps, e => e.includes(exportName));
}

module.exports = exports.default;