js-node

fs.js

import * as mkdirp from 'mkdirp'
import * as rimraf from 'rimraf'
import * as write from 'write'
import * as fse from 'fs-extra'

/**
 * 创建文件夹
 * @param uri 项目根目录相对路径
 */
export async  function createFileFolder(uri: string) {
  await mkdirp(uri)
}

/**
 * 删除路径文件或文件夹
 * @param uri 项目根目录相对路径
 */
export function delFilePath(uri: string): Promise<void> {
  return new Promise((resolve, reject) => {
    rimraf(uri, function (err) {
      if (err) {
        reject(err)
      }
      resolve()
    });
  })
}

export async function wirteFile(path, data) {
  return write(path, data, { newline: true, overwrite: true })
}

/**
 * 强制创建空文件夹
 * @param uri 项目根目录相对路径
 */
export async function forceCreateEmptyFolder(uri: string) {
  await delFilePath(uri)
  await mkdirp(uri)
}

/**
 * 强制创建空文件夹
 * @param uri 项目根目录相对路径
 */
export async function forceCreateEmptyFolders(uris: string[]) {
    await Promise.all(uris.map(i => forceCreateEmptyFolder(i)))
}

export async function copyFile(url, des){
  return await fse.copy(url, des, {
    overwrite: true
  })
}

gitlab.js

import * as request from 'request'
import { gitlabConf } from '../conf'

export class GitlabFn {
  public request = null;
  private loginUrl = gitlabConf.loginUrl
  constructor() {
    this.request = request.defaults({ jar: true })
  }
  login(usernameOrEmail, password) {
    return new Promise((resolve, reject) => {
      this.request.get(this.loginUrl, (err, response, body) => {
        if (err) {
          console.log(err)
          return reject(err)
        }
        if (response.statusCode === 200) {
          const authenticity_token = body.match(/name\=\"authenticity_token\" value=\"(.*.)\" \/\>/)[1].trim()
          this.request.post({
            url: this.loginUrl,
            form: {
              "utf8": "✓",
              "authenticity_token": authenticity_token,
              "user[login]": usernameOrEmail,
              "user[password]": password,
              "user[remember_me]": "0"
            }
          }, (err, response) => {
            if (err) {
              console.log(err)
              reject(err)
            }
            if(/<title\>Sign in · GitLab<\/title>/.test(response.body)){
              reject('gitlab账号密码错误')
            }else{
              resolve()
            }
          })
        } else {
          console.log(`[error] response.state=${response.statusCode}`)
          reject(err)
        }
      })
    })
  }
  getReadme(packageName, gitHead){
    let url = `${gitlabConf.repoUrl}/raw/${gitHead}/packages/${packageName}/README.md?inline=false`
    return new Promise((resolve,reject)=>{
      this.request.get(url, (err, response, body) => {
        if (err) {
          reject(err)
        }
        resolve(body)
      })
    })
  }
}

// 返回gitlab初始化已登录账号
export function GitlabUser(username, password): Promise<GitlabFn> {
  return new Promise(async (resolve, reject) => {
    try {
      const gitlabUser = new GitlabFn()
      await gitlabUser.login(username, password)
      resolve(gitlabUser)
    } catch (err) {
      reject(err)
    }
  })
}

export default GitlabFn

// https://gitlab.weierai.com/
// 接口 /users/sign_in
// post
/**
 * utf8: "✓",
 * authenticity_token
 * user[login]
 * user[password]
 * user[remember_me]: 0
 */
// 创建文件夹

logger.js

import * as chalk from 'chalk'

const getTime = () => {
  return chalk.gray('[' + new Date().toLocaleTimeString() + '] ')
}

function logger() { }
logger.prototype.error = function (msg) {
  console.log(getTime() + chalk.bold.red('err') + ' ' + msg)
}
logger.prototype.success = function (msg) {
  console.log(getTime() + chalk.bold.green('success') + ' ' +msg)
}
logger.prototype.warn = function (msg) {
  console.log(getTime() + chalk.bold.yellow('warn') + ' ' + msg)
}
logger.prototype.info = function (msg) {
  console.log(getTime() + chalk.gray('info ' + msg))
}
logger.prototype.describe = function (title, msg) {
  console.log(getTime() + chalk.bgMagenta('describe') + ' ' + chalk.magenta(title) + ' : ' + msg)
}
logger.prototype.list = function (title, arr) {
  console.log(getTime() + '\n' + chalk.cyan(title) + '\n' + chalk.cyan(arr.map((i, x) => x + 1 + ': ' + i).join('\n')))
}
export default new logger()

npm.js

import * as request from 'request'
import { cloneDeep } from 'lodash'
import { npmConf } from '../conf'

interface Verisons {
  [key: string]: any
}

interface PackageJson {
  readme: string,
  versions: Verisons
}

export class PackageInfo {
  public packageName = ''
  public packageJson: PackageJson = null
  constructor(packageName) {
    this.packageName = packageName
  }
  addVersionToReadme(txt, packageName) {
    return txt + `\n\n[查看版本](/version/${packageName})`
  }
  // 获取所有的包信息
  udtAllInfo(): Promise<PackageJson> {
    return new Promise((resolve, reject) => {
      request.get(`${npmConf.host}/${this.packageName}`, (err, response, body) => {
        if (err) {
          return reject(err)
        }
        this.packageJson = JSON.parse(body)
        resolve(cloneDeep(this.packageJson))
      })
    })
  }
  // 添加版本后缀
  get latestReadme() {
    return this.addVersionToReadme(this.packageJson.readme, this.packageName)
  }

  // 获取指定库下的所有版本信息
  get versions(): string[] {
    return Object.keys(this.packageJson.versions)
  }
  // 获取库指定版本的package.json内容
  getVersinoInfo(version: string) {
    return this.packageJson.versions[version]
  }
}

// 返回库初始化好的工厂类
export function PackageFactory(packageName): Promise<PackageInfo> {
  return new Promise(async (resolve, reject) => {
    try {
      const packageInterface = new PackageInfo(packageName)
      await packageInterface.udtAllInfo()
      resolve(packageInterface)
    } catch (err) {
      reject(err)
    }
  })
}