@modern-js/module-tools 1.0.0-alpha.3

package/dist/js/node/utils/babel.js

@@ -0,0 +1,99 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.resolveBabelConfig = exports.getFinalAlias = void 0;
+
+var _babelPresetModule = require("@modern-js/babel-preset-module");
+
+var _utils = require("@modern-js/utils");
+
+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 getFinalAlias = (modernConfig, option) => {
+  const aliasConfig = (0, _utils.getAlias)(modernConfig.source.alias, option); // 排除内部别名，因为不需要处理
+
+  const finalPaths = {};
+  const internalAliasPrefix = '@modern-js/runtime';
+
+  if (aliasConfig.paths && typeof aliasConfig.paths === 'object') {
+    const pathsKey = Object.keys(aliasConfig.paths);
+
+    for (const key of pathsKey) {
+      if (!key.includes(internalAliasPrefix)) {
+        finalPaths[key] = aliasConfig.paths[key];
+      }
+    }
+  }
+
+  aliasConfig.paths = finalPaths;
+  return aliasConfig;
+};
+
+exports.getFinalAlias = getFinalAlias;
+
+const resolveBabelConfig = (appDirectory, modernConfig, option) => {
+  const {
+    source: {
+      envVars,
+      globalVars,
+      jsxTransformRuntime = 'automatic'
+    },
+    output: {
+      importStyle
+    },
+    tools: {
+      lodash: userLodashOption
+    }
+  } = modernConfig; // alias config
+
+  const aliasConfig = getFinalAlias(modernConfig, _objectSpread({
+    appDirectory
+  }, option)); // lodash config
+
+  const lodashOptions = (0, _utils.applyOptionsChain)({
+    id: ['lodash', 'ramda']
+  }, // TODO: 需要处理类型问题
+  userLodashOption); // babel config
+
+  const internalBabelConfig = (0, _babelPresetModule.getBabelConfig)({
+    appDirectory,
+    enableReactPreset: true,
+    enableTypescriptPreset: true,
+    alias: aliasConfig,
+    envVars,
+    globalVars,
+    lodashOptions,
+    jsxTransformRuntime,
+    importStyle
+  }, {
+    type: option.type,
+    syntax: option.syntax
+  });
+  const babelChain = (0, _babelPresetModule.getModuleBabelChain)({
+    appDirectory,
+    enableReactPreset: true,
+    enableTypescriptPreset: true,
+    alias: aliasConfig,
+    envVars,
+    globalVars,
+    lodashOptions,
+    jsxTransformRuntime,
+    importStyle
+  }, {
+    type: option.type,
+    syntax: option.syntax
+  });
+  const userBabelConfig = modernConfig.tools.babel;
+  return (0, _utils.applyOptionsChain)(internalBabelConfig, // TODO: 感觉 userBabelConfig 的类型应该是TransformOptions
+  userBabelConfig, {
+    chain: babelChain
+  });
+};
+
+exports.resolveBabelConfig = resolveBabelConfig;

package/dist/js/node/utils/color.js

@@ -0,0 +1,12 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.devMenuTitle = void 0;
+
+var _utils = require("@modern-js/utils");
+
+const devMenuTitle = _utils.chalk.rgb(255, 153, 0);
+
+exports.devMenuTitle = devMenuTitle;

package/dist/js/node/utils/copy.js

@@ -0,0 +1,99 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.copyTask = void 0;
+
+var path = _interopRequireWildcard(require("path"));
+
+var _utils = require("@modern-js/utils");
+
+const _excluded = ["glob"];
+
+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 _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
+
+function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
+
+const globby = _utils.Import.lazy('globby', require);
+
+const fastGlob = _utils.Import.lazy('fast-glob', require);
+
+const normalizePath = _utils.Import.lazy('normalize-path', require); // eslint-disable-next-line max-statements
+
+
+const copyTask = async option => {
+  const {
+    modernConfig,
+    appContext
+  } = option;
+  const {
+    appDirectory
+  } = appContext;
+  const {
+    output: {
+      copy,
+      path: outputPath = 'dist'
+    }
+  } = modernConfig;
+
+  if (!copy) {
+    return;
+  }
+
+  try {
+    // 类型暂时这样处理，待之后优化copy的逻辑
+    for (const copyOption of copy) {
+      // 在原来的基础上，引入了类似于 copy-webpck-plugin 的 context 属性，可以设置项目根路径
+      const {
+        context = appDirectory,
+        from,
+        globOptions,
+        to: toOrigin
+      } = copyOption;
+      let fromOrigin = from; // 获取 glob 规则
+
+      let glob = '';
+      let options = {};
+
+      if (fromOrigin !== null && typeof fromOrigin === 'object') {
+        var _fromOrigin = fromOrigin;
+        ({
+          glob
+        } = _fromOrigin);
+        options = _objectWithoutProperties(_fromOrigin, _excluded);
+        _fromOrigin;
+        fromOrigin = glob;
+      } else if (globOptions && typeof globOptions === 'object') {
+        options = globOptions;
+      }
+
+      glob = path.isAbsolute(fromOrigin) ? fromOrigin : path.posix.join(fastGlob.escapePath(normalizePath(path.resolve(context))), fromOrigin); // 计算 glob，获取目标文件
+
+      const paths = await globby(glob, options);
+
+      if (!paths.length) {
+        return;
+      }
+
+      const to = path.normalize(toOrigin ? toOrigin : '');
+      const isToDirectory = path.extname(to) === '';
+      paths.forEach(item => {
+        const relativeFrom = path.relative(context, item); // 如果 to 是目录，通过相对路径计算完整的产物路径；如果 to 是文件，直接作为最终产物路径
+
+        const fileName = isToDirectory ? path.join(to, relativeFrom) : to;
+        const finalToPath = path.resolve(outputPath, fileName);
+
+        _utils.fs.copySync(item, finalToPath);
+      });
+    }
+  } catch (e) {
+    console.error(`copy error: ${e.message}`);
+  }
+};
+
+exports.copyTask = copyTask;

package/dist/js/node/utils/json.js

@@ -0,0 +1,22 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.safeParse = void 0;
+
+const safeParse = jsonString => {
+  try {
+    return {
+      code: 0,
+      value: JSON.parse(jsonString)
+    };
+  } catch (e) {
+    return {
+      code: 1,
+      value: jsonString
+    };
+  }
+};
+
+exports.safeParse = safeParse;

package/dist/js/node/utils/language.js

@@ -0,0 +1,15 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getLocaleLanguage = getLocaleLanguage;
+
+var _utils = require("@modern-js/utils");
+
+const i18n = _utils.Import.lazy('@modern-js/i18n-cli-language-detector', require);
+
+function getLocaleLanguage() {
+  const detector = new i18n.I18CLILanguageDetector();
+  return detector.detect();
+}

package/dist/js/node/utils/logger.js

@@ -0,0 +1,133 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.logTemplate = exports.clearFlag = exports.LoggerText = exports.LoggerManager = void 0;
+
+var _events = _interopRequireDefault(require("events"));
+
+var _utils = require("@modern-js/utils");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+/* eslint-disable max-classes-per-file */
+const chalk = _utils.Import.lazy('chalk', require);
+
+const clearFlag = '\x1Bc';
+exports.clearFlag = clearFlag;
+
+const logTemplate = (title, messageStack, maxLength, {
+  noBottomBorder: _noBottomBorder = false,
+  bottomBorderText: _bottomBorderText = '',
+  noLeftBorder: _noLeftBorder = false,
+  leftBorder: _leftBorder = '│',
+  contentColor: _contentColor = s => s
+} = {}) => {
+  const leftBorderFlag = _noLeftBorder ? '' : _leftBorder;
+  const messageFragments = messageStack.map(p => {
+    p.trim();
+    return `${leftBorderFlag}${p.replace(clearFlag, '')}`;
+  }) // 移除 clearFlag
+  .filter(s => s !== leftBorderFlag) // 过滤空字符串
+  .slice(0, maxLength) // 控制长度
+  .reverse(); // 调换顺序，最新的消息在最后面
+
+  messageFragments[messageFragments.length - 1] = messageFragments[messageFragments.length - 1].trim();
+  const template = `${title}:
+${_contentColor(messageFragments.join(''))}${_noBottomBorder ? '' : `\n${_bottomBorderText}`}`;
+  console.info('template', messageFragments);
+  return template;
+};
+
+exports.logTemplate = logTemplate;
+
+class LoggerText {
+  constructor(option) {
+    this.messages = void 0;
+    this.option = void 0;
+    this.messages = [];
+    this.option = option;
+  }
+
+  append(message) {
+    var _this$option$contentC;
+
+    const replace = ((_this$option$contentC = this.option.contentConfig) === null || _this$option$contentC === void 0 ? void 0 : _this$option$contentC.replace) || [];
+    let content = message;
+
+    for (const r of replace) {
+      content = content.replace(new RegExp(r, 'g'), '');
+    }
+
+    this.messages.push(content);
+  }
+
+  get value() {
+    const {
+      title,
+      maxLength,
+      contentConfig
+    } = this.option;
+    const messages = [...new Set(this.messages)];
+    return logTemplate(title, messages, maxLength, contentConfig);
+  }
+
+}
+
+exports.LoggerText = LoggerText;
+
+class LoggerManager extends _events.default {
+  // constructor() {}
+  createLoggerText(option) {
+    return new LoggerText(option);
+  }
+
+  addStdout(loggerText, stdout, config = {}) {
+    const {
+      event = {
+        data: true,
+        error: true
+      },
+      colors = {
+        data: chalk.green,
+        error: chalk.red,
+        warning: chalk.yellow
+      }
+    } = config;
+
+    if (event.data) {
+      stdout === null || stdout === void 0 ? void 0 : stdout.on('data', chunk => {
+        const data = chunk.toString();
+        const content = colors.data ? colors.data(data) : chalk.green(data);
+        loggerText.append(content);
+        this.emit('data');
+      });
+    }
+
+    if (event.error) {
+      stdout === null || stdout === void 0 ? void 0 : stdout.on('error', error => {
+        const data = error.message;
+        const content = colors.error ? colors.error(data) : chalk.red(data);
+        loggerText.append(content);
+        this.emit('data');
+      });
+    }
+  }
+
+  addStderr(loggerText, stderr) {
+    stderr === null || stderr === void 0 ? void 0 : stderr.on('data', chunk => {
+      const data = chunk.toString();
+      loggerText.append(data);
+    });
+  }
+
+  show(loggerText) {
+    console.info(loggerText.value);
+  }
+
+}
+/* eslint-enable max-classes-per-file */
+
+
+exports.LoggerManager = LoggerManager;

package/dist/js/node/utils/readline.js

@@ -0,0 +1,33 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ReadlineUtils = void 0;
+
+var readline = _interopRequireWildcard(require("readline"));
+
+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; }
+
+// eslint-disable-next-line @typescript-eslint/no-extraneous-class
+class ReadlineUtils {
+  static clearPrevLine(output) {
+    ReadlineUtils.clearLine(output, 1);
+  }
+
+  static clearLine(output, n = 1, dir = -1) {
+    // -1 向上，1 向下
+    const dx = dir === 1 ? 1 : -1;
+
+    for (let i = 0; i < n; i++) {
+      readline.moveCursor(output, 0, dx);
+      readline.clearLine(output, 0);
+      readline.cursorTo(output, 0);
+    }
+  }
+
+}
+
+exports.ReadlineUtils = ReadlineUtils;

package/dist/js/node/utils/tsconfig.js

@@ -0,0 +1,30 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.readTsConfig = exports.existTsConfigFile = void 0;
+
+var _utils = require("@modern-js/utils");
+
+const json5 = _utils.Import.lazy('json5', require);
+
+const readTsConfig = (tsconfigPath, noExistReturn = null) => {
+  // 如果不存在，则返回 noExistReturn
+  if (!_utils.fs.existsSync(tsconfigPath)) {
+    return noExistReturn;
+  }
+
+  const content = _utils.fs.readFileSync(tsconfigPath, 'utf-8');
+
+  return json5.parse(content);
+};
+
+exports.readTsConfig = readTsConfig;
+
+const existTsConfigFile = tsconfigAbsolutePath => {
+  const tsconfig = readTsConfig(tsconfigAbsolutePath);
+  return Boolean(tsconfig);
+};
+
+exports.existTsConfigFile = existTsConfigFile;

package/dist/js/node/utils/tspaths-transform/constants.js

@@ -0,0 +1,10 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.defaultTransformedFunctions = void 0;
+const defaultTransformedFunctions = ['require', 'require.resolve', 'System.import', // Jest methods
+'jest.genMockFromModule', 'jest.mock', 'jest.unmock', 'jest.doMock', 'jest.dontMock', 'jest.setMock', 'jest.requireActual', 'jest.requireMock', // Older Jest methods
+'require.requireActual', 'require.requireMock'];
+exports.defaultTransformedFunctions = defaultTransformedFunctions;

package/dist/js/node/utils/tspaths-transform/index.js

@@ -0,0 +1,155 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.transformDtsAlias = void 0;
+
+var path = _interopRequireWildcard(require("path"));
+
+var parser = _interopRequireWildcard(require("@babel/parser"));
+
+var _traverse = _interopRequireDefault(require("@babel/traverse"));
+
+var _generator = _interopRequireDefault(require("@babel/generator"));
+
+var t = _interopRequireWildcard(require("@babel/types"));
+
+var _tsconfigPaths = require("tsconfig-paths");
+
+var _utils = require("@modern-js/utils");
+
+var _constants = require("./constants");
+
+var _utils2 = require("./utils");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+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; }
+
+const getPathsMap = (paths, sourceDirName = 'src') => {
+  const pathKeys = Object.keys(paths);
+  const pathsMap = {};
+
+  const replaceSrcToTypes = s => s.replace(sourceDirName, 'types');
+
+  for (const key of pathKeys) {
+    const p = paths[key];
+
+    if (typeof p === 'string') {
+      pathsMap[key] = [replaceSrcToTypes(p)];
+    } else {
+      pathsMap[key] = paths[key].map(sp => replaceSrcToTypes(sp));
+    }
+  }
+
+  return pathsMap;
+};
+
+function mapPathString(nodePath, {
+  filename,
+  baseUrl,
+  paths
+}) {
+  if (!t.isStringLiteral(nodePath)) {
+    return;
+  }
+
+  const sourcePath = nodePath.node.value;
+  const currentFile = filename;
+  const pathsMap = getPathsMap(paths);
+  const matchPath = (0, _tsconfigPaths.createMatchPath)(baseUrl, pathsMap, ['index']);
+  const result = matchPath(sourcePath, packageJsonPath => {
+    if (!_utils.fs.existsSync(packageJsonPath)) {
+      return undefined;
+    }
+
+    return _utils.fs.readJSONSync(packageJsonPath);
+  }, filePath => _utils.fs.existsSync(filePath), ['.d.ts']);
+
+  if (result) {
+    const relativePath = path.relative(path.dirname(currentFile), path.dirname(result));
+    const fileName = path.basename(result); // 如果是同级文件，则返回的是 ''
+
+    const filePath = path.normalize(`${relativePath.length === 0 ? '.' : relativePath}/${fileName}`);
+    const replaceString = filePath.startsWith('.') ? filePath : `./${filePath}`;
+    nodePath.replaceWith(t.stringLiteral(replaceString));
+  }
+}
+
+const transformCall = option => nodePath => {
+  const calleePath = nodePath.get('callee');
+
+  const isNormalCall = _constants.defaultTransformedFunctions.some(pattern => (0, _utils2.matchesPattern)(calleePath, pattern));
+
+  if (isNormalCall || (0, _utils2.isImportCall)(nodePath)) {
+    mapPathString(nodePath.get('arguments.0'), option);
+  }
+};
+
+const transformImport = option => nodePath => {
+  mapPathString(nodePath.get('source'), option);
+};
+
+const transformExport = option => nodePath => {
+  mapPathString(nodePath.get('source'), option);
+};
+
+const transfromSingleFileAlias = ({
+  filename,
+  baseUrl,
+  paths
+}) => {
+  const sourceCode = _utils.fs.readFileSync(filename, 'utf-8');
+
+  const ast = parser.parse(sourceCode, {
+    sourceType: 'module',
+    errorRecovery: true,
+    // 防止typescript不支持的语法出现而报错
+    plugins: ['typescript']
+  });
+  (0, _traverse.default)(ast, {
+    CallExpression: transformCall({
+      filename,
+      baseUrl,
+      paths
+    }),
+    ImportDeclaration: transformImport({
+      filename,
+      baseUrl,
+      paths
+    }),
+    ExportDeclaration: transformExport({
+      filename,
+      baseUrl,
+      paths
+    })
+  });
+  return (0, _generator.default)(ast).code;
+};
+
+const transformDtsAlias = option => {
+  const {
+    filenames = [],
+    baseUrl,
+    paths
+  } = option;
+  const transformResult = [];
+
+  for (const filename of filenames) {
+    transformResult.push({
+      path: filename,
+      content: transfromSingleFileAlias({
+        filename,
+        baseUrl,
+        paths
+      })
+    });
+  }
+
+  return transformResult;
+};
+
+exports.transformDtsAlias = transformDtsAlias;

package/dist/js/node/utils/tspaths-transform/utils.js

@@ -0,0 +1,32 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isImportCall = isImportCall;
+exports.matchesPattern = matchesPattern;
+
+var _utils = require("@modern-js/utils");
+
+const t = _utils.Import.lazy('@babel/types', require);
+
+function matchesPattern(calleePath, pattern) {
+  const {
+    node
+  } = calleePath;
+
+  if (t.isMemberExpression(node)) {
+    return calleePath.matchesPattern(pattern);
+  }
+
+  if (!t.isIdentifier(node) || pattern.includes('.')) {
+    return false;
+  }
+
+  const name = pattern.split('.')[0];
+  return node.name === name;
+}
+
+function isImportCall(calleePath) {
+  return t.isImport(calleePath.node.callee);
+}

package/dist/js/node/utils/valide.js

@@ -0,0 +1,41 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.valideBeforeTask = exports.modernConfigValid = void 0;
+
+var _utils = require("@modern-js/utils");
+
+const valideBeforeTask = ({
+  modernConfig,
+  tsconfigPath
+}) => {
+  const modernConfigValidResult = modernConfigValid(modernConfig, {
+    tsconfigPath
+  });
+
+  if (modernConfigValidResult) {
+    console.error(modernConfigValidResult); // eslint-disable-next-line no-process-exit
+
+    process.exit(0);
+  }
+};
+
+exports.valideBeforeTask = valideBeforeTask;
+
+const modernConfigValid = (modernConfig, option) => {
+  const valids = [_utils.validAlias];
+
+  for (const validFn of valids) {
+    const result = validFn(modernConfig, option);
+
+    if (result) {
+      return result;
+    }
+  }
+
+  return null;
+};
+
+exports.modernConfigValid = modernConfigValid;