uni-plugin-light/lib/task.js

uni-app相关插件、loader及webpack基础配置

'use strict';

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

var path = require('path');
var tComm = require('t-comm');
var fs = require('fs');
var globToRegExp = require('glob-to-regexp');
var vueTemplateCompiler = require('vue-template-compiler');

function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }

function _interopNamespace(e) {
  if (e && e.__esModule) return e;
  var n = Object.create(null);
  if (e) {
    Object.keys(e).forEach(function (k) {
      if (k !== 'default') {
        var d = Object.getOwnPropertyDescriptor(e, k);
        Object.defineProperty(n, k, d.get ? d : {
          enumerable: true,
          get: function () { return e[k]; }
        });
      }
    });
  }
  n["default"] = e;
  return Object.freeze(n);
}

var path__namespace = /*#__PURE__*/_interopNamespace(path);
var fs__namespace = /*#__PURE__*/_interopNamespace(fs);
var globToRegExp__default = /*#__PURE__*/_interopDefaultLegacy(globToRegExp);

function _arrayLikeToArray$2(arr, len) {
  if (len == null || len > arr.length) len = arr.length;
  for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];
  return arr2;
}

function _arrayWithoutHoles(arr) {
  if (Array.isArray(arr)) return _arrayLikeToArray$2(arr);
}

function _iterableToArray(iter) {
  if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
}

function _unsupportedIterableToArray$2(o, minLen) {
  if (!o) return;
  if (typeof o === "string") return _arrayLikeToArray$2(o, minLen);
  var n = Object.prototype.toString.call(o).slice(8, -1);
  if (n === "Object" && o.constructor) n = o.constructor.name;
  if (n === "Map" || n === "Set") return Array.from(o);
  if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray$2(o, minLen);
}

function _nonIterableSpread() {
  throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
}

function _toConsumableArray(arr) {
  return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray$2(arr) || _nonIterableSpread();
}

/* eslint-disable @typescript-eslint/no-require-imports */
function getParent(path, level) {
  if (!level) {
    return path.parent;
  }
  return getParent(path.parentPath, level - 1);
}
function findDependencies(content) {
  var parser = require('@babel/parser');
  var traverse = require('@babel/traverse')["default"];
  // const generate = require('@babel/generator').default;
  // const t = require('@babel/types');
  var sourceList = [];
  var ast = parser.parse(content, {
    // 不加这个配置，报错：SyntaxError: 'import' and 'export' may appear only with 'sourceType: "module"'
    sourceType: 'module',
    plugins: ['typescript']
  });
  traverse(ast, {
    CallExpression: function CallExpression(path) {
      if (path.node.callee.name === 'require') {
        var _getParent, _getParent2, _getParent3, _getParent4;
        if (path.node.arguments[0].type === 'StringLiteral') {
          sourceList.push(path.node.arguments[0].value);
        }
        if (getParent(path, 0).type === 'ExpressionStatement' && getParent(path, 1).type === 'BlockStatement' && getParent(path, 2).type === 'ObjectMethod' && getParent(path, 3).type === 'ObjectExpression' && ((_getParent = getParent(path, 4)) === null || _getParent === void 0 ? void 0 : _getParent.type) === 'ObjectProperty' && ((_getParent2 = getParent(path, 4)) === null || _getParent2 === void 0 || (_getParent2 = _getParent2.key) === null || _getParent2 === void 0 ? void 0 : _getParent2.name) === 'components' && ((_getParent3 = getParent(path, 5)) === null || _getParent3 === void 0 ? void 0 : _getParent3.type) === 'ObjectExpression' && ((_getParent4 = getParent(path, 6)) === null || _getParent4 === void 0 ? void 0 : _getParent4.type) === 'ExportDefaultDeclaration' && path.node.arguments[0].type === 'ArrayExpression') {
          sourceList.push(path.node.arguments[0].elements[0].value);
        }
      }
    },
    ImportDeclaration: function ImportDeclaration(path) {
      sourceList.push(path.node.source.value);
    }
  });
  return sourceList;
}

function _createForOfIteratorHelper$1(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray$1(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it["return"] != null) it["return"](); } finally { if (didErr) throw err; } } }; }
function _unsupportedIterableToArray$1(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray$1(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray$1(o, minLen); }
function _arrayLikeToArray$1(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
function isInIgnoreGlob(file, ignoreGlob, projectRoot) {
  var _iterator = _createForOfIteratorHelper$1(ignoreGlob),
    _step;
  try {
    for (_iterator.s(); !(_step = _iterator.n()).done;) {
      var item = _step.value;
      var re = globToRegExp__default["default"](item);
      var relativeFile = path__namespace.relative(projectRoot, file);
      if (re.test(relativeFile)) {
        return true;
      }
    }
  } catch (err) {
    _iterator.e(err);
  } finally {
    _iterator.f();
  }
  return false;
}
function resolveFilePath(file, _ref) {
  var _findFile2;
  var projectRoot = _ref.projectRoot,
    fromFile = _ref.fromFile,
    fileExts = _ref.fileExts;
  if (file.startsWith('src')) {
    var _findFile;
    return (_findFile = findFile(path__namespace.resolve(projectRoot, file), fileExts)) === null || _findFile === void 0 ? void 0 : _findFile.file;
  }
  if (!file.startsWith('.')) {
    // node_modules
    return;
  }
  var dir = path__namespace.dirname(fromFile);
  return (_findFile2 = findFile(path__namespace.resolve(dir, file), fileExts)) === null || _findFile2 === void 0 ? void 0 : _findFile2.file;
}
function parseRoot(root) {
  var list = [];
  if (fs__namespace.existsSync(root)) {
    if (fs__namespace.statSync(root).isDirectory()) {
      tComm.traverseFolder(function (path) {
        list.push(path);
      }, root);
    } else {
      return [root];
    }
  }
  return list;
}
// 传入绝对路径
function findFile(filePath, fileExts) {
  if (fs__namespace.existsSync(filePath)) {
    if (!fs__namespace.statSync(filePath).isDirectory()) {
      return {
        file: filePath
      };
    }
    filePath = path__namespace.resolve(filePath, 'index');
  }
  var _iterator2 = _createForOfIteratorHelper$1(fileExts),
    _step2;
  try {
    for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
      var postfix = _step2.value;
      var newFilePath = "".concat(filePath, ".").concat(postfix);
      if (fs__namespace.existsSync(newFilePath)) {
        return {
          file: newFilePath
        };
      }
    }
  } catch (err) {
    _iterator2.e(err);
  } finally {
    _iterator2.f();
  }
  return null;
}
function readFile(file) {
  var content = fs__namespace.readFileSync(file, {
    encoding: 'utf-8'
  });
  return content;
}
function writeFile(file, data) {
  fs__namespace.writeFileSync(file, data, {
    encoding: 'utf-8'
  });
}
function isVue(file) {
  return file.endsWith('.vue');
}
function findDependenciesFromFile(file) {
  var content = readFile(file);
  if (isVue(file)) {
    var _res$script;
    var res = vueTemplateCompiler.parseComponent(content);
    var styleDependencies = res.styles.map(function (item) {
      return item.src;
    }).filter(function (item) {
      return item;
    });
    return [].concat(_toConsumableArray(findDependencies((res === null || res === void 0 || (_res$script = res.script) === null || _res$script === void 0 ? void 0 : _res$script.content) || '')), _toConsumableArray(styleDependencies));
  }
  if (/\.(scss|css|less)$/.test(file)) {
    return [];
  }
  return findDependencies(content);
}
function copyFile(from, to) {
  if (!fs__namespace.existsSync(to)) {
    tComm.mkDirsSync(path__namespace.dirname(to));
    tComm.execCommand("cp -r ".concat(from, " ").concat(to));
  } else {
    var content = readFile(from);
    writeFile(to, content);
  }
}
function removeJSFile(file) {
  if (!fs__namespace.existsSync(file)) return;
  var extension = path__namespace.extname(file);
  if (extension === '.ts') {
    var jsFile = file.replace(/\.ts$/, '.js');
    if (fs__namespace.existsSync(jsFile)) {
      fs__namespace.unlinkSync(jsFile);
      console.log('[light cli] 删除JS文件', jsFile);
    }
  }
}

var DEFAULT_EXTENSIONS = ['js', 'ts', 'vue',
// 'scss',
// 'css',
'json'];
var CONFIG_KEY_MAP = {
  FILE: 'light-cli.config.js',
  LIGHT_CLI: 'light-cli',
  SYNC_REPO: 'sync-repo'
};

function getRoot() {
  var root = process.cwd();
  return root;
}
function getConfig() {
  var _pkg;
  var root = getRoot();
  var pkg = {};
  var configFile = path__namespace.resolve(root, CONFIG_KEY_MAP.FILE);
  if (fs__namespace.existsSync(configFile)) {
    var _require;
    // eslint-disable-next-line @typescript-eslint/no-require-imports
    return ((_require = require(configFile)) === null || _require === void 0 ? void 0 : _require[CONFIG_KEY_MAP.SYNC_REPO]) || {};
  }
  try {
    var content = fs__namespace.readFileSync(path__namespace.resolve(root, 'package.json'), {
      encoding: 'utf-8'
    });
    pkg = JSON.parse(content);
  } catch (err) {}
  return ((_pkg = pkg) === null || _pkg === void 0 || (_pkg = _pkg[CONFIG_KEY_MAP.LIGHT_CLI]) === null || _pkg === void 0 ? void 0 : _pkg[CONFIG_KEY_MAP.SYNC_REPO]) || {};
}

/* eslint-disable @typescript-eslint/no-require-imports */
function saveJsonToLog(content, file) {
  var needLog = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
  if (!needLog) return;
  createLogDir();
  try {
    fs__namespace.writeFile("./log/".concat(file), JSON.stringify(content, null, 2), {
      encoding: 'utf-8'
    }, function () {});
  } catch (err) {}
}
function createLogDir() {
  if (!fs__namespace.existsSync('./log')) {
    fs__namespace.mkdirSync('./log');
  }
}

function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it["return"] != null) it["return"](); } finally { if (didErr) throw err; } } }; }
function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
var visitedFiles = [];
var fileDependencyMap = {};
function parseParams(files, _ref) {
  var ignore = _ref.ignore,
    projectRoot = _ref.projectRoot;
  return tComm.flat(files.map(function (file) {
    var from;
    var level = Infinity;
    if (typeof file === 'string') {
      from = file;
    } else {
      from = file.from;
      level = file.level || level;
    }
    var parsedFiles;
    if (Array.isArray(from)) {
      parsedFiles = tComm.flat(from.map(function (item) {
        return parseRoot(item);
      }));
    } else {
      parsedFiles = parseRoot(from);
    }
    return parsedFiles.filter(function (item) {
      return !isInIgnoreGlob(item, ignore, projectRoot);
    }).map(function (item) {
      return {
        from: item,
        level: level
      };
    });
  }));
}
function syncRepo() {
  var _getConfig = getConfig(),
    _getConfig$files = _getConfig.files,
    files = _getConfig$files === void 0 ? [] : _getConfig$files,
    target = _getConfig.target,
    _getConfig$ignore = _getConfig.ignore,
    ignore = _getConfig$ignore === void 0 ? [] : _getConfig$ignore,
    _getConfig$extensions = _getConfig.extensions,
    extensions = _getConfig$extensions === void 0 ? DEFAULT_EXTENSIONS : _getConfig$extensions,
    _getConfig$shouldRepl = _getConfig.shouldReplaceJS,
    shouldReplaceJS = _getConfig$shouldRepl === void 0 ? true : _getConfig$shouldRepl;
  if (!files.length) {
    console.error('files 长度不能为0');
    return;
  }
  if (!target) {
    console.log('target 不能为空');
    return;
  }
  var projectRoot = getRoot();
  // visitedFiles.push(...files);
  var parsedFiles = parseParams(files, {
    ignore: ignore,
    projectRoot: projectRoot
  });
  var allDependencies = new Set(parsedFiles.map(function (item) {
    return item.from;
  }));
  findAllDependencies({
    files: parsedFiles,
    projectRoot: projectRoot,
    dependencies: allDependencies,
    extensions: extensions,
    ignore: ignore
  });
  var allDependencyList = Array.from(allDependencies);
  for (var _i = 0, _allDependencyList = allDependencyList; _i < _allDependencyList.length; _i++) {
    var file = _allDependencyList[_i];
    var relativeFile = path__namespace.relative(projectRoot, file);
    var to = path__namespace.resolve(projectRoot, target, relativeFile);
    copyFile(file, to);
    if (shouldReplaceJS) {
      removeJSFile(to);
    }
  }
  saveJsonToLog(fileDependencyMap, 'sync-repo.json');
}
function findAllDependencies(_ref2) {
  var files = _ref2.files,
    projectRoot = _ref2.projectRoot,
    dependencies = _ref2.dependencies,
    extensions = _ref2.extensions,
    ignore = _ref2.ignore;
  var _iterator = _createForOfIteratorHelper(files),
    _step;
  try {
    var _loop = function _loop() {
      var file = _step.value;
      var from = file.from,
        level = file.level;
      if (!level) return 1; // continue
      var foundFile = findFile(from, extensions);
      if (foundFile && !visitedFiles.includes(foundFile.file) && !isInIgnoreGlob(foundFile.file, ignore, projectRoot)) {
        var sourceList = findDependenciesFromFile(foundFile.file).map(function (file) {
          return resolveFilePath(file, {
            projectRoot: projectRoot,
            fromFile: foundFile.file,
            fileExts: extensions
          });
        }).filter(function (item) {
          return item;
        }).filter(function (item) {
          return !isInIgnoreGlob(item, ignore, projectRoot);
        });
        visitedFiles.push(foundFile.file);
        sourceList.forEach(function (item) {
          return dependencies.add(item);
        });
        fileDependencyMap[foundFile.file] = sourceList;
        findAllDependencies({
          files: sourceList.map(function (file) {
            return {
              from: file,
              level: level - 1
            };
          }),
          projectRoot: projectRoot,
          dependencies: dependencies,
          extensions: extensions,
          ignore: ignore
        });
      }
    };
    for (_iterator.s(); !(_step = _iterator.n()).done;) {
      if (_loop()) continue;
    }
  } catch (err) {
    _iterator.e(err);
  } finally {
    _iterator.f();
  }
}

exports.syncRepo = syncRepo;