build-easy/lib/host.js

library build tool.

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.applyAfterHook = applyAfterHook;
exports.applyBeforeHook = applyBeforeHook;
exports.applyHook = applyHook;
exports.compileAlias = compileAlias;
exports.compileDeclaration = compileDeclaration;
exports.compileJsOrTs = compileJsOrTs;
exports.compileLess = compileLess;
exports.compileVueSfc = compileVueSfc;
exports.enablePlumber = enablePlumber;
exports.enableSourcemap = enableSourcemap;
exports.enablefileCache = enablefileCache;
exports.hackGetFile = hackGetFile;
exports.hackSaveFile = hackSaveFile;
exports.logger = logger;
exports.modifySourcemap = modifySourcemap;

function _compilerSfc() {
  const data = require("@build-easy/bundles/model/@vue/compiler-sfc");

  _compilerSfc = function _compilerSfc() {
    return data;
  };

  return data;
}

function _core() {
  const data = require("@build-easy/bundles/model/@babel/core");

  _core = function _core() {
    return data;
  };

  return data;
}

function _gulpTypescript() {
  const data = _interopRequireDefault(require("@build-easy/bundles/model/gulp-typescript"));

  _gulpTypescript = function _gulpTypescript() {
    return data;
  };

  return data;
}

function _gulpSourcemaps() {
  const data = _interopRequireDefault(require("@build-easy/bundles/model/gulp-sourcemaps"));

  _gulpSourcemaps = function _gulpSourcemaps() {
    return data;
  };

  return data;
}

function _gulpPlumber() {
  const data = _interopRequireDefault(require("@build-easy/bundles/model/gulp-plumber"));

  _gulpPlumber = function _gulpPlumber() {
    return data;
  };

  return data;
}

function _through() {
  const data = _interopRequireDefault(require("@build-easy/bundles/model/through2"));

  _through = function _through() {
    return data;
  };

  return data;
}

function _figures() {
  const data = _interopRequireDefault(require("@build-easy/bundles/model/figures"));

  _figures = function _figures() {
    return data;
  };

  return data;
}

function _gulpIf() {
  const data = _interopRequireDefault(require("@build-easy/bundles/model/gulp-if"));

  _gulpIf = function _gulpIf() {
    return data;
  };

  return data;
}

function _gulpLess() {
  const data = _interopRequireDefault(require("@build-easy/bundles/model/gulp-less"));

  _gulpLess = function _gulpLess() {
    return data;
  };

  return data;
}

function _hashSum() {
  const data = _interopRequireDefault(require("@build-easy/bundles/model/hash-sum"));

  _hashSum = function _hashSum() {
    return data;
  };

  return data;
}

function _chalk() {
  const data = _interopRequireDefault(require("@build-easy/bundles/model/chalk"));

  _chalk = function _chalk() {
    return data;
  };

  return data;
}

function _vinyl() {
  const data = _interopRequireDefault(require("@build-easy/bundles/model/vinyl"));

  _vinyl = function _vinyl() {
    return data;
  };

  return data;
}

function _path() {
  const data = _interopRequireDefault(require("path"));

  _path = function _path() {
    return data;
  };

  return data;
}

function _fs() {
  const data = _interopRequireDefault(require("fs"));

  _fs = function _fs() {
    return data;
  };

  return data;
}

var _getBabelConifg = _interopRequireDefault(require("./getBabelConifg"));

var _alias2 = _interopRequireDefault(require("./alias"));

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }

function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }

function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }

const empty = () => {};

const jsxIdent = '__build-easy__jsx__file__';

function logger() {
  return _through().default.obj((file, _, cb) => {
    const ext = _path().default.extname(file.path);

    if (!/d.ts/.test(file.path) && ext) {
      console.log(_chalk().default.green(_figures().default.tick), _chalk().default.green(`Success ${ext.slice(1).toUpperCase()}:`), _path().default.join(_path().default.basename(file.cwd), file.path.replace(file.cwd, '')));
    }

    cb(null, file);
  });
}

function isTransform(regExp, filePath) {
  return regExp.test(filePath) && !filePath.endsWith('.d.ts');
}

function applyHook(func, args) {
  return typeof func === 'function' ? func(args) : _through().default.obj();
}

function modifySourcemap(sourcemap) {
  return (0, _gulpIf().default)(file => !!sourcemap && !file.path.endsWith('.d.ts'), _gulpSourcemaps().default.write('.'));
}

function enablefileCache(cache) {
  return _through().default.obj((file, _, cb) => {
    var _file$contents;

    cache[file.path] = (_file$contents = file.contents) === null || _file$contents === void 0 ? void 0 : _file$contents.toString();

    if (/\.(t|j)sx$/.test(file.basename)) {
      file.contents = Buffer.from(`/*${jsxIdent}*/\n${cache[file.path]}`);
    }

    cb(null, file);
  });
}

function enableSourcemap(sourcemap) {
  return (0, _gulpIf().default)(() => !!sourcemap, _gulpSourcemaps().default.init());
}

function enablePlumber(watch) {
  return (0, _gulpIf().default)(!!watch, (0, _gulpPlumber().default)(empty));
}

function applyBeforeHook(hook) {
  return applyHook(hook, {
    through: _through().default,
    gulpIf: _gulpIf().default
  });
}

function applyAfterHook(hook) {
  return applyHook(hook, {
    through: _through().default,
    gulpIf: _gulpIf().default
  });
}

function compileLess(lessOptions) {
  return (0, _gulpIf().default)(file => file.path.endsWith('.less'), (0, _gulpLess().default)(lessOptions));
}

function hackSaveFile() {
  return (0, _gulpIf().default)(file => {
    return isTransform(/\.tsx?$/, file.path);
  }, _through().default.obj(function (file, _, cb) {
    this.push(new (_vinyl().default)({
      cwd: file.cwd,
      base: file.base,
      contents: file.contents,
      path: file.path + 'backup',
      sourceMap: file.sourceMap
    }));
    cb(null, file);
  }));
}

function hackGetFile(moduleType, output) {
  return _through().default.obj(function (file, _, cb) {
    if (isTransform(/\.tsx?backup$/, file.path)) {
      file.path = file.path.replace('backup', '');
      return cb(null, file);
    }

    if (moduleType === 'all' && /\.d\.ts$/.test(file.path)) {
      file.path = _path().default.join(file.cwd, output, 'types', file.path.replace(file.base, ''));
      return cb(null, file);
    }

    if (moduleType === 'all' && !/\.(j|t)sx?$/.test(file.path)) {
      const esmFile = {
        path: _path().default.join(file.cwd, output, 'esm', file.path.replace(file.base, '')),
        base: file.base,
        contents: file.contents,
        cwd: file.cwd
      };
      const cjsFile = {
        path: _path().default.join(file.cwd, output, 'cjs', file.path.replace(file.base, '')),
        base: file.base,
        contents: file.contents,
        cwd: file.cwd
      };
      this.push(new (_vinyl().default)(esmFile));
      this.push(new (_vinyl().default)(cjsFile));
      cb();
    } else {
      cb(null, file);
    }
  });
}

function compileDeclaration(currentDirPath, cwd, tsCompilerOptions) {
  let tsconfigPath = _path().default.join(currentDirPath, 'tsconfig.json');

  let isTsconfig = _fs().default.existsSync(tsconfigPath);

  if (cwd !== currentDirPath && !isTsconfig) {
    tsconfigPath = _path().default.join(cwd, 'tsconfig.json');
    isTsconfig = _fs().default.existsSync(tsconfigPath);
  }

  const ts = isTsconfig ? _gulpTypescript().default.createProject(tsconfigPath, _objectSpread(_objectSpread({}, tsCompilerOptions), {}, {
    declaration: true,
    emitDeclarationOnly: true,
    moduleResolution: 'node'
  })) : () => _through().default.obj((file, _, cb) => {
    cb(null, file);
  }); // typescript may not be installed

  return (0, _gulpIf().default)(file => {
    return isTransform(/\.tsx?$/, file.path) && isTsconfig;
  }, ts({
    error: err => {
      console.log(`${_chalk().default.red('➜ [Error]: ')}${err.message}`);
    }
  })); // No files are output except d.ts
}

function compileAlias(alias) {
  return _through().default.obj((file, _, cb) => {
    const _alias = _objectSpread({}, alias);

    if (Object.keys(_alias).length) {
      const dirname = _path().default.dirname(file.path);

      const ext = _path().default.extname(file.relative);

      file.contents = Buffer.from((0, _alias2.default)({
        ext,
        contents: file.contents.toString(),
        dirname,
        aliasMap: _alias
      }));
    }

    cb(null, file);
  });
}

function compileVueSfc(injectCss) {
  const EXT_REGEXP = /\.\w+$/;
  const RENDER_FN = '__vue_render__';
  const VUEIDS = '__vue_sfc__';
  const EXPORT = 'export default';

  function trim(code) {
    return code.replace(/\/\/\n/g, '').trim();
  }

  function injectRender(render) {
    return render.replace('export function render', `function ${RENDER_FN}`);
  }

  function injectScopeId(scopeId) {
    return `\n${VUEIDS}.__scopeId = '${scopeId}'`;
  }

  function getSfcStylePath(filePath, ext, index) {
    const number = index !== 0 ? `-${index}` : '';
    return filePath.replace(EXT_REGEXP, `${number}.${ext}`);
  }

  function injectStyle(styles, filePath) {
    const imports = styles.reduce((code, _, index) => code + `import './${_path().default.basename(getSfcStylePath(filePath, 'css', index))}';\n`, '');
    return imports;
  }

  function transform(file, _, cb) {
    const content = file.contents.toString();

    const _parse = (0, _compilerSfc().parse)(content, {
      filename: file.path
    }),
          descriptor = _parse.descriptor;

    const template = descriptor.template,
          styles = descriptor.styles,
          script = descriptor.script,
          filename = descriptor.filename,
          scriptSetup = descriptor.scriptSetup;
    const hasScoped = styles.some(s => s.scoped);
    const scopeId = hasScoped ? `data-v-${(0, _hashSum().default)(content)}` : null;

    if (script || scriptSetup) {
      var _script$lang;

      const lang = (_script$lang = script === null || script === void 0 ? void 0 : script.lang) !== null && _script$lang !== void 0 ? _script$lang : 'js';
      const scriptFilePath = file.path.replace(EXT_REGEXP, `.${lang}`);
      let makeScript = injectCss ? injectStyle(styles, file.path) : '';

      if (script) {
        if (template) {
          const render = (0, _compilerSfc().compileTemplate)({
            id: scopeId !== null && scopeId !== void 0 ? scopeId : filename,
            source: template.content,
            filename: file.path
          }).code;
          makeScript += injectRender(render);
        }

        makeScript += script.content;
        makeScript += template ? `${VUEIDS}.render = ${RENDER_FN}\n` : '';
      }

      if (scriptSetup) {
        makeScript += (0, _compilerSfc().compileScript)(descriptor, {
          id: scopeId !== null && scopeId !== void 0 ? scopeId : filename,
          refTransform: true,
          inlineTemplate: true
        }).content;
      }

      makeScript = makeScript.replace(EXPORT, `const ${VUEIDS} =`);

      if (scopeId) {
        makeScript += injectScopeId(scopeId);
      }

      makeScript += `\n${VUEIDS}.__file = '${_path().default.basename(filename)}'\n${EXPORT} ${VUEIDS}`;
      this.push(new (_vinyl().default)({
        path: scriptFilePath,
        contents: Buffer.from(makeScript),
        cwd: file.cwd,
        base: file.base
      }));
    }

    if (styles) {
      styles.forEach((style, index) => {
        var _style$lang;

        const cssFilePath = getSfcStylePath(file.path, (_style$lang = style.lang) !== null && _style$lang !== void 0 ? _style$lang : 'css', index);
        let styleSource = trim(style.content);

        if (style.scoped) {
          styleSource = (0, _compilerSfc().compileStyle)({
            id: scopeId,
            scoped: true,
            source: styleSource,
            filename: cssFilePath
          }).code;
        }

        this.push(new (_vinyl().default)({
          path: cssFilePath,
          contents: Buffer.from(styleSource),
          cwd: file.cwd,
          base: file.base
        }));
      });
    }

    cb();
  }

  return (0, _gulpIf().default)(file => isTransform(/\.vue$/, file.path), _through().default.obj(transform));
}

function compileJsOrTs(config, currentEntryDirPath) {
  return (0, _gulpIf().default)(file => isTransform(/\.(t|j)sx?$/, file.path), _through().default.obj(function (file, _, cb) {
    var _babelFileResult$code;

    const sourcemap = config.sourcemap,
          target = config.target,
          nodeFiles = config.nodeFiles,
          browserFiles = config.browserFiles,
          moduleType = config.moduleType,
          output = config.output;

    const vinylSourcemapsApply = require('@build-easy/bundles/model/vinyl-sourcemaps-apply');

    let isBrowser = target === 'browser';
    const ident = new RegExp(`/*${jsxIdent}*/`);

    if (/\.(t|j)sx$/.test(file.path) || ident.test(file.contents.toString())) {
      isBrowser = true;
    } else {
      const currentFilePath = _path().default.relative(currentEntryDirPath, file.path);

      if (isBrowser && nodeFiles && nodeFiles.includes(currentFilePath)) {
        isBrowser = false;
      }

      if (!isBrowser && browserFiles && browserFiles.includes(currentFilePath)) {
        isBrowser = true;
      }
    }

    const replaceExtname = file => file.replace(_path().default.extname(file), '.js');

    if (moduleType === 'all') {
      var _babelFileResultCjs$c, _babelFileResultEsm$c;

      const babelConfigCjs = (0, _getBabelConifg.default)(config, isBrowser, 'cjs');
      const babelFileResultCjs = (0, _core().transformSync)(file.contents, _objectSpread(_objectSpread({}, babelConfigCjs), {}, {
        filename: file.path,
        configFile: false,
        sourceMaps: sourcemap
      }));

      if (file.sourceMap && sourcemap) {
        if (!babelFileResultCjs.map.file) {
          babelFileResultCjs.map.file = file.sourceMap.file;
        }

        vinylSourcemapsApply(file, babelFileResultCjs.map);
      }

      this.push(new (_vinyl().default)({
        contents: Buffer.from((_babelFileResultCjs$c = babelFileResultCjs.code) !== null && _babelFileResultCjs$c !== void 0 ? _babelFileResultCjs$c : ''),
        cwd: file.cwd,
        base: file.base,
        path: _path().default.join(file.cwd, output, 'cjs', replaceExtname(file.path.replace(file.base, '')))
      }));
      const babelConfigEsm = (0, _getBabelConifg.default)(config, isBrowser, 'esm');
      const babelFileResultEsm = (0, _core().transformSync)(file.contents, _objectSpread(_objectSpread({}, babelConfigEsm), {}, {
        filename: file.path,
        configFile: false,
        sourceMaps: sourcemap
      }));

      if (file.sourceMap && sourcemap) {
        if (!babelFileResultEsm.map.file) {
          babelFileResultEsm.map.file = file.sourceMap.file;
        }

        vinylSourcemapsApply(file, babelFileResultEsm.map);
      }

      this.push(new (_vinyl().default)({
        contents: Buffer.from((_babelFileResultEsm$c = babelFileResultEsm.code) !== null && _babelFileResultEsm$c !== void 0 ? _babelFileResultEsm$c : ''),
        cwd: file.cwd,
        base: file.base,
        path: _path().default.join(file.cwd, output, 'esm', replaceExtname(file.path.replace(file.base, '')))
      }));
      return cb();
    }

    const babelConfig = (0, _getBabelConifg.default)(config, isBrowser, moduleType);
    const babelFileResult = (0, _core().transformSync)(file.contents, _objectSpread(_objectSpread({}, babelConfig), {}, {
      filename: file.path,
      configFile: false,
      sourceMaps: sourcemap
    }));
    file.contents = Buffer.from((_babelFileResult$code = babelFileResult.code) !== null && _babelFileResult$code !== void 0 ? _babelFileResult$code : '');

    if (file.sourceMap && sourcemap) {
      if (!babelFileResult.map.file) {
        babelFileResult.map.file = file.sourceMap.file;
      }

      vinylSourcemapsApply(file, babelFileResult.map);
    }

    file.path = replaceExtname(file.path);
    cb(null, file);
  }));
}