@ctsj/build/src/buildpackagets.js

一个基于webpack的打包工具

#!/usr/bin/env node

const fs = require('fs');
const { spawn } = require('child_process');
const logger = require('npmlog');
const path = require('path');

const { getEnv, isWin32 } = require('./util');

// 运行脚本的路径
const runtimePath = process.cwd();

// 脚本所在的路径
const codePath = __dirname;

const commandPath = path.join(codePath, '../', 'node_modules', '.bin', path.sep);

// buildpackage生成的目录名称
let generateDirName = 'lib';

// buildpackage原始名称
const srcDirName = 'src';

// p参数
let p;
// tsP的实际路径
let pTarget;

// 代码输出路径
let outputPath;

// 代码编译路径
let compilePath;

let index = 0;

// buildpackage的所有任务
const tasks = [
  // 清除生成目录
  clearTask,
  // tsc转换，转换typescript
  tscTask,
  // 样式
  gulpTask,
];

/**
 * clearTask
 * 清除输出目录
 * @return {Promise}
 */
function clearTask() {
  return new Promise((resolve) => {
    const command = isWin32() ? `rimraf.cmd` : `rimraf`;

    const rimrafProcess = spawn(command, [outputPath], {
      cwd: path.join(codePath, '../'),
      encoding: 'utf-8',
      env: getEnv(commandPath),
    });

    // rimrafProcess.stdout.on('data', (data) => {
    //   logger.info(`stdout: ${data}`);
    // });
    //
    // rimrafProcess.stderr.on('data', (data) => {
    //   logger.info(`stderr: ${data}`);
    // });

    rimrafProcess.on('close', () => {
      // logger.info(`rimrafClose：${code}`);
      resolve();
    });
  });
}

/**
 * tscTask
 * 转换src到lib
 * @return {Promise}
 */
function tscTask() {
  return new Promise((resolve) => {
    const command = isWin32() ? `tsc.cmd` : `tsc`;

    const tscProcess = spawn(command, ['-p', pTarget], {
      cwd: path.join(codePath, '../'),
      encoding: 'utf-8',
      env: getEnv(commandPath),
    });

    tscProcess.stdout.on('data', (data) => {
      logger.info(`${data}`);
    });

    tscProcess.stdin.on('data', (data) => {
      logger.info(`${data}`);
    });

    tscProcess.stderr.on('data', (data) => {
      logger.warn(`${data}`);
    });

    tscProcess.on('close', () => {
      resolve();
    });
  });
}

/**
 * gulpTask
 * @return {Promise}
 */
function gulpTask() {
  return new Promise((resolve) => {
    const command = isWin32() ? `gulp.cmd` : `gulp`;

    const gulpProcess = spawn(
      command,
      [
        '--outputpath',
        // 输出路径
        path.join(outputPath, path.sep),
        '--compilepath',
        // 编译目录
        path.join(compilePath, path.sep),
      ],
      {
        cwd: path.join(codePath, '../'),
        encoding: 'utf-8',
        env: getEnv(commandPath),
      },
    );

    gulpProcess.stdout.on('data', (data) => {
      logger.info(`${data}`);
    });

    gulpProcess.stdin.on('data', (data) => {
      logger.info(`${data}`);
    });

    gulpProcess.stderr.on('data', (data) => {
      logger.warn(`${data}`);
    });

    gulpProcess.on('close', () => {
      resolve();
    });
  });
}

/**
 * loopTask
 * @return {Promise}
 */
function loopTask() {
  return new Promise((resolve, reject) => {
    if (index >= tasks.length) {
      resolve();
    } else {
      // eslint-disable-next-line no-plusplus
      const task = tasks[index++];
      if (task) {
        task()
          .then(() => {
            loopTask().then(() => {
              resolve();
            });
          })
          .catch((error) => {
            reject(error);
          });
      } else {
        reject();
      }
    }
  });
}

module.exports = {
  /**
   * build
   * @param {String} - srcPath
   */
  build({ srcpath, output = 'lib' }) {
    p = srcpath;
    generateDirName = output;
    outputPath = path.join(runtimePath, generateDirName);

    // 输入了p参数
    if (p) {
      // 文件描述符
      const stat = fs.statSync(p);

      // 绝对路径
      if (path.isAbsolute(p)) {
        // 是文件
        if (stat.isFile()) {
          // ts
          pTarget = p;
          // gulp
          compilePath = path.join(runtimePath, srcDirName);
        }
        // 是目录
        else {
          // ts
          pTarget = p;
          // gulp
          compilePath = path.join(p, srcDirName);
        }
      }
      // 相对路径
      else {
        // 是文件
        if (stat.isFile()) {
          // ts
          pTarget = path.join(runtimePath, p);
          // gulp
          compilePath = path.join(runtimePath, srcDirName);
        }
        // 是目录
        else {
          // ts
          pTarget = path.join(runtimePath, p);
          // gulp
          compilePath = path.join(runtimePath, p, srcDirName);
        }
      }
    }
    // 没输入p参数
    else {
      // ts
      pTarget = runtimePath;
      // gulp
      compilePath = path.join(runtimePath, srcDirName);
    }
    // logger.info('buildpackage-p----------------------', p);

    loopTask()
      .then(() => {
        logger.info('finish');
        process.exit();
      })
      .catch((error) => {
        logger.error(error);
      });
  },
};