@modern-js/babel-compiler 1.0.0-alpha.3

package/dist/js/node/buildWatch.js

@@ -0,0 +1,132 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.runBuildWatch = exports.buildWatch = exports.BuildWatchEvent = exports.BuildWatchEmitter = void 0;
+
+var path = _interopRequireWildcard(require("path"));
+
+var Event = _interopRequireWildcard(require("events"));
+
+var _utils = require("@modern-js/utils");
+
+var _build = require("./build");
+
+var _compilerErrorResult = require("./compilerErrorResult");
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (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 = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { 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 BuildWatchEvent = {
+  firstCompiler: 'first-compiler',
+  compiling: 'compiling',
+  watchingCompiler: 'watching-compiler'
+};
+exports.BuildWatchEvent = BuildWatchEvent;
+
+class BuildWatchEmitter extends Event.EventEmitter {
+  constructor(...args) {
+    super(...args);
+    this._initFn = void 0;
+  }
+
+  setInitFn(fn) {
+    this._initFn = fn;
+  }
+
+  async watch() {
+    if (typeof this._initFn === 'function') {
+      return this._initFn(this);
+    }
+
+    return null;
+  }
+
+}
+
+exports.BuildWatchEmitter = BuildWatchEmitter;
+
+const runBuildWatch = async (option, babelConfig = {}, emitter) => {
+  emitter.emit(BuildWatchEvent.compiling);
+  const errorResult = new _compilerErrorResult.CompilerErrorResult();
+  const watchDir = option.watchDir;
+  const {
+    distDir,
+    quiet
+  } = option; // 第一次正常构建
+
+  const fisrtBuildResult = await (0, _build.build)(option, babelConfig);
+  const {
+    code
+  } = fisrtBuildResult;
+
+  if (code === 1) {
+    errorResult.init(fisrtBuildResult);
+    emitter.emit(BuildWatchEvent.firstCompiler, errorResult.value);
+  } else {
+    emitter.emit(BuildWatchEvent.firstCompiler, fisrtBuildResult);
+  }
+
+  return (0, _utils.watch)(watchDir, async ({
+    changeType,
+    changedFilePath
+  }) => {
+    emitter.emit(BuildWatchEvent.compiling);
+
+    if (changeType === _utils.WatchChangeType.UNLINK) {
+      const removeFiles = [path.normalize(`./${distDir}/${path.relative(watchDir, changedFilePath)}`)];
+
+      if (!quiet) {
+        _utils.logger.info(`remove file: ${removeFiles.join(',')}`);
+      }
+
+      const result = {
+        code: 0,
+        message: `remove file: ${removeFiles.join(',')}`,
+        removeFiles
+      };
+      emitter.emit(BuildWatchEvent.watchingCompiler, result);
+      return;
+    }
+
+    const result = await (0, _build.build)(_objectSpread(_objectSpread({}, option), {}, {
+      filenames: [changedFilePath]
+    }), babelConfig);
+
+    if (result.code === 1) {
+      errorResult.update(result.messageDetails || []);
+      emitter.emit(BuildWatchEvent.watchingCompiler, errorResult.value);
+      !quiet && _utils.logger.info(errorResult.value.message);
+    } else {
+      errorResult.removeByFileName(changedFilePath); // 如果该文件没有报错，则更新该文件状态并检查是否还存在其他报错文件
+
+      if (errorResult.checkExistError()) {
+        emitter.emit(BuildWatchEvent.watchingCompiler, _objectSpread(_objectSpread({}, errorResult.value), {}, {
+          virtualDists: result.virtualDists
+        }));
+        !quiet && _utils.logger.info(errorResult.value.message);
+      } else {
+        emitter.emit(BuildWatchEvent.watchingCompiler, result);
+        !quiet && _utils.logger.info(result.message);
+      }
+    }
+  }, [`${watchDir}/**/*.d.ts`]);
+};
+
+exports.runBuildWatch = runBuildWatch;
+
+const buildWatch = (option, babelConfig = {}) => {
+  const buildWatchEmitter = new BuildWatchEmitter();
+  buildWatchEmitter.setInitFn(runBuildWatch.bind(null, option, babelConfig));
+  return buildWatchEmitter;
+};
+
+exports.buildWatch = buildWatch;

package/dist/js/node/compiler.js

@@ -0,0 +1,146 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.resolveSourceMap = exports.isRes = exports.getDistFilePath = exports.compiler = void 0;
+
+var path = _interopRequireWildcard(require("path"));
+
+var babel = _interopRequireWildcard(require("@babel/core"));
+
+var _utils = require("@modern-js/utils");
+
+var utils = _interopRequireWildcard(require("./utils"));
+
+var _constants = require("./constants");
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (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 = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { 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 defaultDistDir = 'dist';
+
+const isRes = r => Boolean(r);
+
+exports.isRes = isRes;
+
+const getDistFilePath = option => {
+  const {
+    filepath,
+    rootDir,
+    distDir,
+    extMap
+  } = option;
+  const ext = path.extname(filepath);
+  return path.join(distDir, path.relative(rootDir, filepath).replace(ext, extMap[ext]));
+};
+
+exports.getDistFilePath = getDistFilePath;
+
+const resolveSourceMap = option => {
+  const {
+    babelRes,
+    distFilePath,
+    enableVirtualDist = false
+  } = option;
+  const mapLoc = `${distFilePath}.map`;
+  babelRes.code = utils.addSourceMappingUrl(babelRes.code, mapLoc);
+
+  if (babelRes.map) {
+    babelRes.map.file = distFilePath;
+  }
+
+  const sourceMapVirtualDist = {
+    sourcemap: JSON.stringify(babelRes.map),
+    sourceMapPath: mapLoc
+  };
+
+  if (enableVirtualDist) {
+    return sourceMapVirtualDist;
+  }
+
+  _utils.fs.ensureDirSync(path.dirname(mapLoc));
+
+  _utils.fs.writeFileSync(mapLoc, JSON.stringify(babelRes.map));
+
+  return sourceMapVirtualDist;
+};
+
+exports.resolveSourceMap = resolveSourceMap;
+
+const compiler = option => {
+  const {
+    filepath,
+    rootDir,
+    enableVirtualDist = false,
+    distDir = path.join(path.dirname(rootDir), defaultDistDir),
+    verbose = false,
+    babelConfig = {},
+    distFileExtMap = _constants.defaultDistFileExtMap,
+    quiet = false
+  } = option;
+  const babelRes = babel.transformFileSync(filepath, babelConfig);
+  let virtualDist = null;
+
+  if (!isRes(babelRes)) {
+    throw new Error(`${filepath} happen error`);
+  }
+
+  const distFilePath = getDistFilePath({
+    filepath,
+    rootDir,
+    distDir,
+    extMap: distFileExtMap
+  });
+
+  if (enableVirtualDist) {
+    virtualDist = {
+      distPath: distFilePath,
+      sourceMapPath: '',
+      code: '',
+      sourcemap: ''
+    };
+  }
+
+  if (babelRes !== null && babelRes !== void 0 && babelRes.map && babelConfig.sourceMaps && babelConfig.sourceMaps !== 'inline') {
+    if (virtualDist) {
+      virtualDist = _objectSpread(_objectSpread({}, virtualDist), resolveSourceMap({
+        babelRes,
+        distFilePath,
+        enableVirtualDist
+      }));
+    } else {
+      resolveSourceMap({
+        babelRes,
+        distFilePath,
+        enableVirtualDist
+      });
+    }
+  }
+
+  if (virtualDist) {
+    virtualDist = _objectSpread(_objectSpread({}, virtualDist), {}, {
+      distPath: distFilePath,
+      code: babelRes.code
+    });
+  } else {
+    _utils.fs.ensureDirSync(path.dirname(distFilePath));
+
+    _utils.fs.writeFileSync(distFilePath, babelRes.code);
+  }
+
+  if (verbose && !quiet) {
+    _utils.logger.info(`${filepath} => ${distFilePath}`);
+  }
+
+  return virtualDist;
+};
+
+exports.compiler = compiler;

package/dist/js/node/compilerErrorResult.js

@@ -0,0 +1,57 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.CompilerErrorResult = void 0;
+
+class CompilerErrorResult {
+  constructor(initErrorResult) {
+    this._messageDetails = void 0;
+    this.init(initErrorResult);
+  }
+
+  init(initErrorResult) {
+    this._messageDetails = (initErrorResult === null || initErrorResult === void 0 ? void 0 : initErrorResult.messageDetails) || [];
+  }
+
+  update(messageDetails) {
+    for (const messageDetail of messageDetails) {
+      // 遍历存不存在该文件报错信息，不存在则增加，否则更新内容
+      const addError = !this._messageDetails.some(detail => {
+        if (detail.filename === messageDetail.filename) {
+          // 如果错误栈里存在该文件报错信息，则更新内容
+          detail.content = messageDetail.content;
+          return true;
+        }
+
+        return false;
+      });
+
+      if (addError) {
+        this._messageDetails.push(messageDetail);
+      }
+    }
+  }
+
+  removeByFileName(filename) {
+    this._messageDetails = this._messageDetails.filter(detail => detail.filename !== filename);
+  }
+
+  get value() {
+    var _this$_messageDetails;
+
+    return {
+      code: 1,
+      message: `Compilation failure ${(_this$_messageDetails = this._messageDetails) === null || _this$_messageDetails === void 0 ? void 0 : _this$_messageDetails.length} files with Babel.`,
+      messageDetails: this._messageDetails
+    };
+  }
+
+  checkExistError() {
+    return this._messageDetails.length > 0;
+  }
+
+}
+
+exports.CompilerErrorResult = CompilerErrorResult;

package/dist/js/node/constants.js

@@ -0,0 +1,13 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.defaultDistFileExtMap = void 0;
+const defaultDistFileExtMap = {
+  '.js': '.js',
+  '.jsx': '.js',
+  '.ts': '.js',
+  '.tsx': '.js'
+};
+exports.defaultDistFileExtMap = defaultDistFileExtMap;

package/dist/js/node/defaults.js

@@ -0,0 +1,30 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.mergeDefaultOption = void 0;
+
+var _constants = require("./constants");
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (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 = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { 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 defaultOptions = {
+  enableWatch: false,
+  enableVirtualDist: false,
+  extensions: [],
+  filenames: [],
+  distFileExtMap: _constants.defaultDistFileExtMap,
+  ignore: [],
+  quiet: false,
+  verbose: false,
+  clean: false
+};
+
+const mergeDefaultOption = compilerOptions => _objectSpread(_objectSpread({}, defaultOptions), compilerOptions);
+
+exports.mergeDefaultOption = mergeDefaultOption;

package/dist/js/node/getFinalOption.js

@@ -0,0 +1,101 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getGlobPattern = exports.getFinalExtensions = exports.getFinalCompilerOption = exports.getFilesFromDir = void 0;
+
+var glob = _interopRequireWildcard(require("glob"));
+
+var _core = require("@babel/core");
+
+var _defaults = require("./defaults");
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (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 = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { 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 getGlobPattern = (dir, extensions) => {
+  if (extensions.length > 1) {
+    return `${dir}/**/*{${extensions.join(',')}}`;
+  } else if (extensions.length === 1) {
+    return `${dir}/**/*${extensions[0]}`;
+  } else {
+    return `${dir}/**/*`;
+  }
+};
+
+exports.getGlobPattern = getGlobPattern;
+
+const getFinalExtensions = extensions => {
+  const isExtensions = ext => Array.isArray(ext);
+
+  const isExtensionsFunc = ext => typeof ext === 'function';
+
+  if (isExtensions(extensions)) {
+    return [...extensions, ..._core.DEFAULT_EXTENSIONS];
+  } else if (isExtensionsFunc(extensions)) {
+    return extensions(_core.DEFAULT_EXTENSIONS);
+  } else {
+    return _core.DEFAULT_EXTENSIONS;
+  }
+};
+
+exports.getFinalExtensions = getFinalExtensions;
+
+const getFilesFromDir = ({
+  dir,
+  finalExt: _finalExt = [],
+  ignore: _ignore = []
+}) => {
+  let globFindFilenames = [];
+  const globPattern = getGlobPattern(dir, _finalExt);
+  globFindFilenames = glob.sync(globPattern, {
+    ignore: _ignore
+  });
+  return globFindFilenames;
+};
+
+exports.getFilesFromDir = getFilesFromDir;
+
+const getFinalCompilerOption = option => {
+  const optionWithDefault = (0, _defaults.mergeDefaultOption)(option);
+  const {
+    sourceDir,
+    ignore,
+    enableWatch = false,
+    watchDir,
+    extensions = _core.DEFAULT_EXTENSIONS
+  } = option;
+  let globFindFilenames = [];
+  const finalExt = getFinalExtensions(extensions);
+
+  if (sourceDir) {
+    globFindFilenames = getFilesFromDir({
+      dir: sourceDir,
+      ignore,
+      finalExt
+    });
+  }
+
+  if (enableWatch) {
+    // 开启watch模式，清空通过 sourceDir 找到的文件，而改为使用watchDirs
+    globFindFilenames = getFilesFromDir({
+      dir: watchDir,
+      ignore,
+      finalExt
+    });
+  }
+
+  return _objectSpread(_objectSpread({}, optionWithDefault), {}, {
+    filenames: [...optionWithDefault.filenames, ...globFindFilenames]
+  });
+};
+
+exports.getFinalCompilerOption = getFinalCompilerOption;

package/dist/js/node/index.js

@@ -0,0 +1,59 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _exportNames = {
+  compiler: true
+};
+exports.compiler = compiler;
+
+var _getFinalOption = require("./getFinalOption");
+
+var _build = require("./build");
+
+var _buildWatch = require("./buildWatch");
+
+Object.keys(_buildWatch).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _buildWatch[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _buildWatch[key];
+    }
+  });
+});
+
+var _validate = require("./validate");
+
+var _type = require("./type");
+
+Object.keys(_type).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _type[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _type[key];
+    }
+  });
+});
+
+async function compiler(compilerOptions, babelOptions = {}) {
+  const validRet = (0, _validate.validate)(compilerOptions);
+
+  if (validRet) {
+    return validRet;
+  }
+
+  const finalCompilerOption = (0, _getFinalOption.getFinalCompilerOption)(compilerOptions);
+
+  if (compilerOptions.enableWatch) {
+    return (0, _buildWatch.buildWatch)(finalCompilerOption, babelOptions);
+  } else {
+    return (0, _build.build)(finalCompilerOption, babelOptions);
+  }
+}

package/dist/js/node/type.js

@@ -0,0 +1,5 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});

package/dist/js/node/utils.js

@@ -0,0 +1,16 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.addSourceMappingUrl = addSourceMappingUrl;
+
+var path = _interopRequireWildcard(require("path"));
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+function addSourceMappingUrl(code, loc) {
+  return `${code}\n//# sourceMappingURL=${path.basename(loc)}`;
+}

package/dist/js/node/validate.js

@@ -0,0 +1,71 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.watchDirValidMessage = exports.validateWatchDir = exports.validateSourceDirAndFileNames = exports.validate = exports.sourceDirAndFileNamesValidMessage = void 0;
+
+var _utils = require("@modern-js/utils");
+
+const sourceDirAndFileNamesValidMessage = 'At least one of the sourceDir and filenames configurations must be configured';
+exports.sourceDirAndFileNamesValidMessage = sourceDirAndFileNamesValidMessage;
+const watchDirValidMessage = 'should set watchDir when enableWatch is true';
+exports.watchDirValidMessage = watchDirValidMessage;
+
+const validateSourceDirAndFileNames = compilerOptions => {
+  const {
+    sourceDir,
+    filenames,
+    quiet
+  } = compilerOptions;
+
+  if (!sourceDir && !filenames) {
+    if (!quiet) {
+      _utils.logger.error(sourceDirAndFileNamesValidMessage);
+    }
+
+    return {
+      code: 1,
+      message: sourceDirAndFileNamesValidMessage,
+      virtualDists: []
+    };
+  }
+
+  return null;
+};
+
+exports.validateSourceDirAndFileNames = validateSourceDirAndFileNames;
+
+const validateWatchDir = compilerOptions => {
+  const {
+    watchDir,
+    enableWatch,
+    quiet
+  } = compilerOptions;
+
+  if (enableWatch && !watchDir) {
+    if (!quiet) {
+      _utils.logger.error(watchDirValidMessage);
+    }
+
+    return {
+      code: 1,
+      message: watchDirValidMessage,
+      virtualDists: []
+    };
+  }
+
+  return null;
+};
+
+exports.validateWatchDir = validateWatchDir;
+
+const validate = compilerOptions => {
+  if (compilerOptions.enableWatch) {
+    return validateWatchDir(compilerOptions);
+  }
+
+  return validateSourceDirAndFileNames(compilerOptions);
+};
+
+exports.validate = validate;

package/dist/types/build.d.ts

@@ -0,0 +1,2 @@
+import type { IFinaleCompilerOptions, BabelOptions, ICompilerResult } from './type';
+export declare const build: (option: IFinaleCompilerOptions, babelConfig?: BabelOptions) => Promise<ICompilerResult>;

package/dist/types/buildWatch.d.ts

@@ -0,0 +1,16 @@
+/// <reference types="node" />
+import * as Event from 'events';
+import { FSWatcher } from 'chokidar';
+import type { IFinaleCompilerOptions, BabelOptions } from './type';
+export declare const BuildWatchEvent: {
+  firstCompiler: string;
+  compiling: string;
+  watchingCompiler: string;
+};
+export declare class BuildWatchEmitter extends Event.EventEmitter {
+  private _initFn;
+  setInitFn(fn: (emitter: BuildWatchEmitter) => Promise<any> | any): void;
+  watch(): Promise<FSWatcher | null>;
+}
+export declare const runBuildWatch: (option: IFinaleCompilerOptions, babelConfig: import("@babel/core").TransformOptions | undefined, emitter: BuildWatchEmitter) => Promise<FSWatcher>;
+export declare const buildWatch: (option: IFinaleCompilerOptions, babelConfig?: BabelOptions) => BuildWatchEmitter;