TypeScript mem-fs.create函数代码示例

  private async copyScaffold (): Promise<any> {
    const { proName, proPath, projectType, projectTypeTitle } = this.options

    // 内存编辑器
    const store = memFs.create()
    const fsEditor = editor.create(store)

    // 拷贝 project.common 脚手架模板
    fsEditor.copyTpl(
      util.getScaffoldPath(ScaffoldType.Project, 'common'),
      proPath,
      this.options,
      null,
      {
        globOptions: {
          dot: true
        }
      }
    )

    // 拷贝 project.type 脚手架模板
    fsEditor.copyTpl(
      util.getScaffoldPath(ScaffoldType.Project, projectType),
      proPath,
      this.options
    )

    return new Promise((resolve, reject) => {
      // 保存
      fsEditor.commit(() => {
        log.newline()
        log.msg(LogType.CREATE, `项目 "${proName}" in "${proPath}"`)

        // 输入拷贝 或 新增 的日志信息
        let files = glob.sync('**', {
          cwd: proPath
        })
        files.forEach(file => log.msg(LogType.COPY, file))

        log.msg(LogType.COMPLETE, `"${projectTypeTitle}"项目已创建完成`)
        resolve()
      })
    })
  }

  /**
   * 新建页面脚手架模板
   *
   * @param {NewData} newData
   */
  private async newPage (newData: NewData) {
    let { pageName } = newData

    // 内存编辑器
    const store = memFs.create()
    const fsEditor = editor.create(store)

    // page 目标地址
    let destPagePath = util.getDestPagePath(pageName)

    // 验证 page 目标地址
    if (fs.existsSync(destPagePath)) {
      log.output(LogType.ERROR, `创建失败，因为页面 "${pageName}" 已经存在`, destPagePath)
      return
    }

    // 将 page 脚手架模板路径下的文件拷贝到 page 目标路径下
    fsEditor.copyTpl(
      util.getScaffoldPath(ScaffoldType.Page),
      destPagePath,
      newData
    )

    return new Promise((resolve, reject) => {
      // 提交编辑器信息
      fsEditor.commit(() => {
        log.newline()
        log.output(LogType.CREATE, `页面 "${pageName}"`, destPagePath)

        // 输入拷贝 或 新增 的日志信息
        glob.sync('**', {
          cwd: destPagePath
        }).forEach(file => log.msg(LogType.COPY, file))

        log.msg(LogType.COMPLETE, `页面 "${pageName}" 创建完成`)

        resolve()
      })
    })
  }

import * as fs from 'mem-fs';

const store: fs.Store = fs.create();
const file = store.get('hello');

const file2 = store.add(file)
    .each(file => console.dir(store.get(file.path)))
    .get('test');

 constructor () {
   const store = memFs.create()
   this.fs = editor.create(store)
   this.sourceRoot(path.join(getRootPath()))
   this.init()
 }

import { Transform } from 'stream';

import * as memFs from 'mem-fs';
import * as editor from 'mem-fs-editor';

const store = memFs.create();
const fs = editor.create(store);

fs.write('template.js', 'var a = 1; console.log(\'<%= foo %>\', a);');
fs.append('template.js', 'var b = 2;');

fs.copy('template.js', 'template.tpl', {
    globOptions: {
        cwd: '.'
    },
    process: (contents) => contents
});

fs.copyTpl('template.tpl', 'output.js', {
    foo: 'bar'
});

const obj = fs.readJSON('template.json');
fs.writeJSON('template.json', obj);

fs.writeJSON('template.json', 'qwer'); // should not be an error, because the parameter is passed to JSON.stringify and it accepts the string
// fs.extendJSON('template.json', 'qwer'); // should be an error, because it does not make sense to extend a json with string

// should accept both versions of commit - with filters and without:
const cb = (err: any) => ({adsf: 'adsf'});
fs.commit(cb);

import * as fs from 'mem-fs';

const store = fs.create();
const file = store.get('hello');

store.add(file, 'hahahahah');

store.each(file => console.dir(store.get(file.path)));

  /**
   * 新建组件脚手架模板
   *
   * @param {NewData} newData
   */
  private async newPackage (newData: NewData) {
    let { pkgName, pkgNameSuffix } = newData
    // 内存编辑器
    const store = memFs.create()
    const fsEditor = editor.create(store)

    // package 目标地址
    let destPackagePath = util.getDestPackagePath(pkgName)

    // page 目标地址
    let destPagePath = util.getDestPagePath(pkgNameSuffix)

    // 验证 package 目标地址
    if (fs.existsSync(destPackagePath)) {
      log.output(LogType.ERROR, `创建失败，因为组件 "${pkgName}" 已经存在`, destPackagePath)
      return
    }

    // 验证 page 目标地址
    if (fs.existsSync(destPagePath)) {
      log.output(LogType.ERROR, `创建失败，因为页面 "${pkgNameSuffix}" 已经存在`, destPagePath)
      return
    }

    // 将 package 脚手架模板路径下的文件拷贝到 package 目标路径下
    fsEditor.copyTpl(
      util.getScaffoldPath(ScaffoldType.Package),
      destPackagePath,
      newData,
      null,
      {
        globOptions: {
          dot: true
        }
      }
    )

    // 创建并写入 package/.npmignore 文件
    // fsEditor.write(
    //   util.getDestPackagePath(pkgName, '.npmignore'),
    //   'test\n*.log\n'
    // )

    // 将 example 脚手架模板路径下的文件拷贝到 page 目标路径下
    fsEditor.copyTpl(
      util.getScaffoldPath(ScaffoldType.Example),
      destPagePath,
      newData
    )

    return new Promise((resolve, reject) => {
      // 提交编辑器信息
      fsEditor.commit(() => {
        log.newline()
        log.output(LogType.CREATE, `组件 "${pkgName}"`, destPackagePath)
        // 输入拷贝 或 新增 的日志信息
        glob.sync('**', {
          cwd: destPackagePath
        }).forEach(file => log.msg(LogType.COPY, file))
        log.msg(LogType.COMPLETE, `组件 "${pkgName}" 创建完成`)

        log.newline()
        log.output(LogType.CREATE, `示例页面 "${pkgNameSuffix}"`, destPagePath)
        // 输入拷贝 或 新增 的日志信息
        glob.sync('**', {
          cwd: destPagePath
        }).forEach(file => log.msg(LogType.COPY, file))
        log.msg(LogType.COMPLETE, `示例页面 "${pkgNameSuffix}" 创建完成`)

        resolve()
      })
    })
  }