babel-plugin-import-bk-magic-vue/lib/index.js

babel-plugin-import-bk-magic-vue

"use strict";

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

var _path = require("path");

var _helperModuleImports = require("@babel/helper-module-imports");

const transformName = name => {
  if (!name) {
    return '';
  }

  name = name.replace(/^(bk)*/g, '');
  return name.replace(/[A-Z]/g, (ch, index) => {
    if (index === 0) {
      return ch.toLowerCase();
    }

    return '-' + ch.toLowerCase();
  });
};

const dontNeedCssFileModName = ['bkTransferDom', transformName('bkTransferDom'), 'bkClickoutside', transformName('bkClickoutside'), 'bkCheckboxGroup', transformName('bkCheckboxGroup'), 'bkFormItem', transformName('bkFormItem'), 'bkOption', transformName('bkOption'), 'bkOptionGroup', transformName('bkOptionGroup'), 'bkRadioGroup', transformName('bkRadioGroup'), 'bkTabPanel', transformName('bkTabPanel'), 'bkTableColumn', transformName('bkTableColumn'), 'bkAnimateNumber', transformName('bkAnimateNumber'), 'bkBreadcrumbItem', transformName('bkBreadcrumbItem'), 'locale', transformName('locale'), 'lang', transformName('lang'), 'localeMixin', transformName('localeMixin'), 'popManager', transformName('popManager'), 'zIndexManager', transformName('zIndexManager'), 'deepmerge', transformName('deepmerge'), 'svg-icon', transformName('svg-icon')];
const specialModName = {
  bkDatePicker: ['date-picker.min.css', 'date-picker.base.min.css'],
  [`${transformName('bkDatePicker')}`]: ['date-picker.min.css', 'date-picker.base.min.css'],
  bkTimePicker: ['time-picker.min.css', 'date-picker.base.min.css'],
  [`${transformName('bkTimePicker')}`]: ['time-picker.min.css', 'date-picker.base.min.css'],
  bkSearchSelect: ['search-select.min.css', 'search-select-menu.min.css'],
  [`${transformName('bkSearchSelect')}`]: ['search-select.min.css', 'search-select-menu.min.css'],
  bkRate: ['rate.min.css', 'star.min.css'],
  [`${transformName('bkRate')}`]: ['rate.min.css', 'star.min.css'],
  bkIcon: ['common.min.css'],
  [`${transformName('bkIcon')}`]: ['common.min.css'],
  tippy: ['common.min.css'],
  [`${transformName('tippy')}`]: ['popover.min.css'],
  bkTableSettingContent: ['table.min.css'],
  [`${transformName('bkTableSettingContent')}`]: ['table.min.css']
};
const directivesMap = {
  bkTooltips: 'tooltips',
  bkClickoutside: 'clickoutside',
  bkOverflowTips: 'overflow-tips',
  bkTransferDom: 'transfer-dom',
  bkCopy: 'copy'
};
const mixinsMap = {
  localeMixin: 'locale'
};
const localeMap = {
  lang: 'lang'
};

const addCommonStyle = (path, source, notCommonCssList, baseLibName) => {
  if (source.indexOf(baseLibName) === 0 && notCommonCssList.indexOf(source) < 0) {
    (0, _helperModuleImports.addSideEffect)(path, `${baseLibName}/lib/ui/common.min.css`);
  }
};

const addComponentStyle = (file, transformedName, baseLibName) => {
  const list = specialModName[transformedName];

  if (list && list.length) {
    list.forEach(item => {
      (0, _helperModuleImports.addSideEffect)(file.path, `${baseLibName}/lib/ui/${item}`);
    });
  } else {
    (0, _helperModuleImports.addSideEffect)(file.path, `${baseLibName}/lib/ui/${transformedName}.min.css`);
  }
};

const createImportDefaultSpecifier = (modName, file, curState, baseLibName) => {
  if (!curState.cache[modName]) {
    let importedSource = '';

    if (directivesMap[modName]) {
      importedSource = `${baseLibName}/lib/directives/${directivesMap[modName]}`;
    } else if (mixinsMap[modName]) {
      importedSource = `${baseLibName}/lib/${mixinsMap[modName]}`;
    } else if (localeMap[modName]) {
      importedSource = `${baseLibName}/lib/locale/${localeMap[modName]}`;
    } else {
      importedSource = `${baseLibName}/lib/${modName === 'localeMixin' ? modName : transformName(modName)}`;
    }

    curState.cache[modName] = (0, _helperModuleImports.addDefault)(file.path, importedSource, {
      nameHint: modName
    });
  }

  return Object.assign({}, curState.cache[modName]);
};

function _default({
  types: t
}) {
  let baseLibName = '';
  const states = {};
  const stateKey = `$importKey${+new Date()}`;

  const getCurState = state => {
    if (!states[stateKey]) {
      states[stateKey] = {};
    }

    return states[stateKey];
  };

  return {
    visitor: {
      Program: {
        enter(path, state) {
          baseLibName = state.opts && state.opts.baseLibName || 'bk-magic-vue';
          const curState = getCurState(state);
          curState.cache = Object.create(null);
          curState.importSpecified = Object.create(null);
          curState.waitRemovePathList = [];
        },

        exit(path, state) {
          getCurState(state).waitRemovePathList.forEach(p => !p.removed && p.remove());
        }

      },

      ImportDeclaration(path, state) {
        const node = path.node;

        if (!node) {
          return;
        }

        const file = path && path.hub && path.hub.file || state && state.file;
        const modName = node.source.value;

        if (modName === baseLibName) {
          const curState = getCurState(state);
          const specifiers = node.specifiers;
          const len = specifiers.length;

          if (len === 0) {
            (0, _helperModuleImports.addSideEffect)(file.path, `${baseLibName}/dist/bk-magic-vue.min.css`);
            return;
          }

          if (len === 1) {
            const firstSpecifier = node.specifiers[0];

            if (t.isImportDefaultSpecifier(firstSpecifier)) {
              (0, _helperModuleImports.addSideEffect)(file.path, `${baseLibName}/dist/bk-magic-vue.min.css`);
              return;
            }
          }

          for (let i = 0; i < len; i++) {
            const spec = specifiers[i];

            if (t.isImportSpecifier(spec)) {
              curState.importSpecified[spec.local.name] = spec.imported.name;
            }
          }

          curState.waitRemovePathList.push(path);
        } else {
          if (modName.indexOf(baseLibName) >= 0 && ((0, _path.extname)(modName) === '.js' || (0, _path.extname)(modName) === '')) {
            if (dontNeedCssFileModName.indexOf((0, _path.basename)(modName)) < 0) {
              addComponentStyle(file, (0, _path.basename)(modName), baseLibName);
              const notCommonCssList = [`${baseLibName}/lib/ui/common.css`, `${baseLibName}/lib/ui/common.min.css`, `${baseLibName}/lib/ui/bk-magic-vue.css`, `${baseLibName}/lib/ui/bk-magic-vue.min.css`, `${baseLibName}/dist/bk-magic-vue.css`, `${baseLibName}/dist/bk-magic-vue.min.css`];
              addCommonStyle(file.path, modName, notCommonCssList, baseLibName);
            }
          }
        }
      },

      Property(path, state) {
        const curState = getCurState(state);
        const node = path.node;

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

        if (curState.importSpecified[node.value.name] && path.scope.hasBinding(node.value.name) && path.scope.getBinding(node.value.name).path.type === 'ImportSpecifier') {
          const file = path && path.hub && path.hub.file || state && state.file;
          node.value = createImportDefaultSpecifier(node.value.name, file, curState, baseLibName);
        }
      },

      VariableDeclarator(path, state) {
        const curState = getCurState(state);
        const node = path.node;

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

        if (curState.importSpecified[node.init.name] && path.scope.hasBinding(node.init.name) && path.scope.getBinding(node.init.name).path.type === 'ImportSpecifier') {
          const file = path && path.hub && path.hub.file || state && state.file;
          node.init = createImportDefaultSpecifier(node.init.name, file, curState, baseLibName);
        }
      },

      ExportDefaultDeclaration(path, state) {
        const curState = getCurState(state);
        const node = path.node;
        const props = ['declaration'];

        for (let i = 0; i < props.length; i++) {
          const prop = props[i];

          if (!t.isIdentifier(node[prop])) {
            continue;
          }

          if (curState.importSpecified[node[prop].name]) {
            const file = path && path.hub && path.hub.file || state && state.file;
            node[prop] = createImportDefaultSpecifier(curState.importSpecified[node[prop].name], file, curState, baseLibName);
          }
        }
      },

      LogicalExpression(path, state) {
        const curState = getCurState(state);
        const node = path.node;
        const props = ['left', 'right'];

        for (let i = 0; i < props.length; i++) {
          const prop = props[i];

          if (!t.isIdentifier(node[prop])) {
            continue;
          }

          if (curState.importSpecified[node[prop].name]) {
            const file = path && path.hub && path.hub.file || state && state.file;
            node[prop] = createImportDefaultSpecifier(curState.importSpecified[node[prop].name], file, curState, baseLibName);
          }
        }
      },

      ConditionalExpression(path, state) {
        const curState = getCurState(state);
        const node = path.node;
        const props = ['test', 'consequent', 'alternate'];

        for (let i = 0; i < props.length; i++) {
          const prop = props[i];

          if (!t.isIdentifier(node[prop])) {
            continue;
          }

          if (curState.importSpecified[node[prop].name]) {
            const file = path && path.hub && path.hub.file || state && state.file;
            node[prop] = createImportDefaultSpecifier(curState.importSpecified[node[prop].name], file, curState, baseLibName);
          }
        }
      },

      BinaryExpression(path, state) {
        const curState = getCurState(state);
        const node = path.node;
        const props = ['left', 'right'];

        for (let i = 0; i < props.length; i++) {
          const prop = props[i];

          if (!t.isIdentifier(node[prop])) {
            continue;
          }

          if (curState.importSpecified[node[prop].name]) {
            const file = path && path.hub && path.hub.file || state && state.file;
            node[prop] = createImportDefaultSpecifier(curState.importSpecified[node[prop].name], file, curState, baseLibName);
          }
        }
      },

      MemberExpression(path, state) {
        const curState = getCurState(state);
        const node = path.node;

        if (!node.object || !node.object.name) {
          return;
        }

        const file = path && path.hub && path.hub.file || state && state.file;

        if (curState.importSpecified[node.object.name]) {
          node.object = createImportDefaultSpecifier(curState.importSpecified[node.object.name], file, curState, baseLibName);
        }
      },

      ArrayExpression(path, state) {
        const curState = getCurState(state);
        const node = path.node;
        const file = path && path.hub && path.hub.file || state && state.file;
        const props = node.elements.map((elem, index) => index);

        for (let i = 0; i < props.length; i++) {
          const prop = props[i];

          if (!t.isIdentifier(node.elements[prop])) {
            continue;
          }

          if (curState.importSpecified[node.elements[prop].name]) {
            node.elements[prop] = createImportDefaultSpecifier(curState.importSpecified[node.elements[prop].name], file, curState, baseLibName);
          }
        }
      },

      CallExpression(path, state) {
        const curState = getCurState(state);
        const node = path.node;
        const file = path && path.hub && path.hub.file || state && state.file;

        if (t.isIdentifier(node.callee) && curState.importSpecified[node.callee.name]) {
          node.callee = createImportDefaultSpecifier(curState.importSpecified[node.callee.name], file, curState, baseLibName);
        }

        const props = node.arguments.map((elem, index) => index);

        for (let i = 0; i < props.length; i++) {
          const prop = props[i];

          if (!t.isIdentifier(node.arguments[prop])) {
            continue;
          }

          if (curState.importSpecified[node.arguments[prop].name] && path.scope.hasBinding(node.arguments[prop].name) && path.scope.getBinding(node.arguments[prop].name).path.type === 'ImportSpecifier') {
            node.arguments[prop] = createImportDefaultSpecifier(curState.importSpecified[node.arguments[prop].name], file, curState, baseLibName);
          }
        }
      },

      NewExpression(path, state) {
        const curState = getCurState(state);
        const node = path.node;
        const file = path && path.hub && path.hub.file || state && state.file;

        if (t.isIdentifier(node.callee) && curState.importSpecified[node.callee.name]) {
          node.callee = createImportDefaultSpecifier(curState.importSpecified[node.callee.name], file, curState, baseLibName);
        }

        const props = node.arguments.map((elem, index) => index);

        for (let i = 0; i < props.length; i++) {
          const prop = props[i];

          if (!t.isIdentifier(node.arguments[prop])) {
            continue;
          }

          if (curState.importSpecified[node.arguments[prop].name] && path.scope.hasBinding(node.arguments[prop].name) && path.scope.getBinding(node.arguments[prop].name).path.type === 'ImportSpecifier') {
            node.arguments[prop] = createImportDefaultSpecifier(curState.importSpecified[node.arguments[prop].name], file, curState, baseLibName);
          }
        }
      },

      IfStatement(path, state) {
        const curState = getCurState(state);
        const node = path.node;

        if (curState.importSpecified[node.test.name]) {
          const file = path && path.hub && path.hub.file || state && state.file;
          node.test = createImportDefaultSpecifier(curState.importSpecified[node.test.name], file, curState, baseLibName);
        }
      },

      ExpressionStatement(path, state) {
        const curState = getCurState(state);
        const node = path.node;

        if (!t.isAssignmentExpression(node.expression)) {
          return;
        }

        const file = path && path.hub && path.hub.file || state && state.file;
        const props = ['right'];

        for (let i = 0; i < props.length; i++) {
          const prop = props[i];

          if (!t.isIdentifier(node.expression[prop])) {
            continue;
          }

          if (curState.importSpecified[node.expression[prop].name]) {
            node.expression[prop] = createImportDefaultSpecifier(curState.importSpecified[node.expression[prop].name], file, curState, baseLibName);
          }
        }
      },

      ReturnStatement(path, state) {
        const curState = getCurState(state);
        const node = path.node;

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

        if (curState.importSpecified[node.argument.name]) {
          const file = path && path.hub && path.hub.file || state && state.file;
          node.argument = createImportDefaultSpecifier(node.argument.name, file, curState, baseLibName);
        }
      }

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