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

package/dist/js/modern/utils/copy.js

@@ -0,0 +1,80 @@
+const _excluded = ["glob"];
+
+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; }
+
+import * as path from 'path';
+import { fs, Import } from '@modern-js/utils';
+const globby = Import.lazy('globby', require);
+const fastGlob = Import.lazy('fast-glob', require);
+const normalizePath = Import.lazy('normalize-path', require); // eslint-disable-next-line max-statements
+
+export 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);
+        fs.copySync(item, finalToPath);
+      });
+    }
+  } catch (e) {
+    console.error(`copy error: ${e.message}`);
+  }
+};

package/dist/js/modern/utils/json.js

@@ -0,0 +1,13 @@
+export const safeParse = jsonString => {
+  try {
+    return {
+      code: 0,
+      value: JSON.parse(jsonString)
+    };
+  } catch (e) {
+    return {
+      code: 1,
+      value: jsonString
+    };
+  }
+};

package/dist/js/modern/utils/language.js

@@ -0,0 +1,6 @@
+import { Import } from '@modern-js/utils';
+const i18n = Import.lazy('@modern-js/i18n-cli-language-detector', require);
+export function getLocaleLanguage() {
+  const detector = new i18n.I18CLILanguageDetector();
+  return detector.detect();
+}

package/dist/js/modern/utils/logger.js

@@ -0,0 +1,110 @@
+/* eslint-disable max-classes-per-file */
+import EventEmitter from 'events';
+import { Import } from '@modern-js/utils';
+const chalk = Import.lazy('chalk', require);
+export const clearFlag = '\x1Bc';
+export 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;
+};
+export 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);
+  }
+
+}
+export class LoggerManager extends EventEmitter {
+  // 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 */

package/dist/js/modern/utils/readline.js

@@ -0,0 +1,19 @@
+import * as readline from 'readline'; // eslint-disable-next-line @typescript-eslint/no-extraneous-class
+
+export 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);
+    }
+  }
+
+}

package/dist/js/modern/utils/tsconfig.js

@@ -0,0 +1,15 @@
+import { fs, Import } from '@modern-js/utils';
+const json5 = Import.lazy('json5', require);
+export const readTsConfig = (tsconfigPath, noExistReturn = null) => {
+  // 如果不存在，则返回 noExistReturn
+  if (!fs.existsSync(tsconfigPath)) {
+    return noExistReturn;
+  }
+
+  const content = fs.readFileSync(tsconfigPath, 'utf-8');
+  return json5.parse(content);
+};
+export const existTsConfigFile = tsconfigAbsolutePath => {
+  const tsconfig = readTsConfig(tsconfigAbsolutePath);
+  return Boolean(tsconfig);
+};

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

@@ -0,0 +1,3 @@
+export 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'];

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

@@ -0,0 +1,130 @@
+import * as path from 'path';
+import * as parser from '@babel/parser';
+import traverse from '@babel/traverse';
+import generator from '@babel/generator';
+import * as t from '@babel/types';
+import { createMatchPath } from 'tsconfig-paths';
+import { fs } from '@modern-js/utils';
+import { defaultTransformedFunctions } from "./constants";
+import { matchesPattern, isImportCall } from "./utils";
+
+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 = createMatchPath(baseUrl, pathsMap, ['index']);
+  const result = matchPath(sourcePath, packageJsonPath => {
+    if (!fs.existsSync(packageJsonPath)) {
+      return undefined;
+    }
+
+    return fs.readJSONSync(packageJsonPath);
+  }, filePath => 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 = defaultTransformedFunctions.some(pattern => matchesPattern(calleePath, pattern));
+
+  if (isNormalCall || 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 = fs.readFileSync(filename, 'utf-8');
+  const ast = parser.parse(sourceCode, {
+    sourceType: 'module',
+    errorRecovery: true,
+    // 防止typescript不支持的语法出现而报错
+    plugins: ['typescript']
+  });
+  traverse(ast, {
+    CallExpression: transformCall({
+      filename,
+      baseUrl,
+      paths
+    }),
+    ImportDeclaration: transformImport({
+      filename,
+      baseUrl,
+      paths
+    }),
+    ExportDeclaration: transformExport({
+      filename,
+      baseUrl,
+      paths
+    })
+  });
+  return generator(ast).code;
+};
+
+export 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;
+};

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

@@ -0,0 +1,21 @@
+import { Import } from '@modern-js/utils';
+const t = Import.lazy('@babel/types', require);
+export 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;
+}
+export function isImportCall(calleePath) {
+  return t.isImport(calleePath.node.callee);
+}

package/dist/js/modern/utils/valide.js

@@ -0,0 +1,28 @@
+import { validAlias } from '@modern-js/utils';
+export const valideBeforeTask = ({
+  modernConfig,
+  tsconfigPath
+}) => {
+  const modernConfigValidResult = modernConfigValid(modernConfig, {
+    tsconfigPath
+  });
+
+  if (modernConfigValidResult) {
+    console.error(modernConfigValidResult); // eslint-disable-next-line no-process-exit
+
+    process.exit(0);
+  }
+};
+export const modernConfigValid = (modernConfig, option) => {
+  const valids = [validAlias];
+
+  for (const validFn of valids) {
+    const result = validFn(modernConfig, option);
+
+    if (result) {
+      return result;
+    }
+  }
+
+  return null;
+};

package/dist/js/node/cli/build.js

@@ -0,0 +1,21 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.buildCli = void 0;
+
+var _utils = require("@modern-js/utils");
+
+const local = _utils.Import.lazy('../locale/index', require);
+
+const commands = _utils.Import.lazy('../commands', require);
+
+const buildCli = program => {
+  // TODO: 初始化环境变量
+  program.command('build').usage('[options]').description(local.i18n.t(local.localeKeys.command.build.describe)).option('-w, --watch', local.i18n.t(local.localeKeys.command.build.watch)).option('--tsconfig [tsconfig]', local.i18n.t(local.localeKeys.command.build.tsconfig), './tsconfig.json').option('--style-only', local.i18n.t(local.localeKeys.command.build.style_only)).option('--platform [platform]', local.i18n.t(local.localeKeys.command.build.platform)).option('--no-tsc', local.i18n.t(local.localeKeys.command.build.no_tsc)).option('--no-clear', local.i18n.t(local.localeKeys.command.build.no_clear)).action(async subCommand => {
+    await commands.build(subCommand);
+  });
+};
+
+exports.buildCli = buildCli;

package/dist/js/node/cli/dev.js

@@ -0,0 +1,20 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.devCli = void 0;
+
+var _utils = require("@modern-js/utils");
+
+const local = _utils.Import.lazy('../locale', require);
+
+const commands = _utils.Import.lazy('../commands', require);
+
+const devCli = program => {
+  program.command('dev').usage('[options]').description(local.i18n.t(local.localeKeys.command.dev.describe)).option('--tsconfig [tsconfig]', local.i18n.t(local.localeKeys.command.build.tsconfig), './tsconfig.json').action(async params => {
+    await commands.dev(params);
+  });
+};
+
+exports.devCli = devCli;

package/dist/js/node/cli/index.js

@@ -0,0 +1,44 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _build = require("./build");
+
+Object.keys(_build).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _build[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _build[key];
+    }
+  });
+});
+
+var _dev = require("./dev");
+
+Object.keys(_dev).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _dev[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _dev[key];
+    }
+  });
+});
+
+var _new = require("./new");
+
+Object.keys(_new).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _new[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _new[key];
+    }
+  });
+});

package/dist/js/node/cli/new.js

@@ -0,0 +1,28 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.newCli = void 0;
+
+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 newAction = _utils.Import.lazy('@modern-js/new-action', require);
+
+const local = _utils.Import.lazy('../locale', require);
+
+const newCli = (program, locale) => {
+  program.command('new').usage('[options]').description(local.i18n.t(local.localeKeys.command.new.describe)).option('-d, --debug', local.i18n.t(local.localeKeys.command.new.debug), false).option('-c, --config <config>', local.i18n.t(local.localeKeys.command.new.config)).option('--dist-tag <tag>', local.i18n.t(local.localeKeys.command.new.distTag)).option('--registry', local.i18n.t(local.localeKeys.command.new.registry)).action(async options => {
+    await newAction.ModuleNewAction(_objectSpread(_objectSpread({}, options), {}, {
+      locale
+    }));
+  });
+};
+
+exports.newCli = newCli;

package/dist/js/node/commands/build.js

@@ -0,0 +1,76 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.build = void 0;
+
+var path = _interopRequireWildcard(require("path"));
+
+var _utils = require("@modern-js/utils");
+
+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 tsConfigutils = _utils.Import.lazy('../utils/tsconfig', require);
+
+const valid = _utils.Import.lazy('../utils/valide', require);
+
+const buildFeature = _utils.Import.lazy('../features/build', require);
+
+const core = _utils.Import.lazy('@modern-js/core', require);
+
+const dotenv = _utils.Import.lazy('dotenv', require);
+
+const build = async ({
+  watch: _watch = false,
+  tsconfig: tsconfigName,
+  tsc,
+  clear: _clear = true,
+  platform
+}) => {
+  const {
+    value: {
+      appDirectory
+    }
+  } = core.useAppContext();
+  const modernConfig = core.useResolvedConfigContext().value;
+  const {
+    output: {
+      path: outputPath = 'dist'
+    }
+  } = modernConfig;
+  const tsconfigPath = path.join(appDirectory, tsconfigName);
+  dotenv.config();
+  const isTsProject = tsConfigutils.existTsConfigFile(tsconfigPath);
+  const enableTscCompiler = isTsProject && tsc;
+  valid.valideBeforeTask({
+    modernConfig,
+    tsconfigPath
+  });
+
+  if (_clear) {
+    _utils.fs.removeSync(path.join(appDirectory, outputPath));
+  } // TODO: 一些配置只需要从modernConfig中获取
+
+
+  await buildFeature.build({
+    enableWatchMode: _watch,
+    isTsProject,
+    platform,
+    sourceDir: 'src',
+    tsconfigName,
+    enableTscCompiler
+  }, modernConfig);
+  process.on('SIGBREAK', () => {
+    console.info('exit');
+    const tempTsconfigFilePath = path.join(appDirectory, './tsconfig.temp.json');
+
+    if (_utils.fs.existsSync(tempTsconfigFilePath)) {
+      _utils.fs.removeSync(tempTsconfigFilePath);
+    }
+  });
+};
+
+exports.build = build;

package/dist/js/node/commands/dev.js

@@ -0,0 +1,49 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.dev = void 0;
+
+var path = _interopRequireWildcard(require("path"));
+
+var _utils = require("@modern-js/utils");
+
+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 devFeature = _utils.Import.lazy('../features/dev', require);
+
+const core = _utils.Import.lazy('@modern-js/core', require);
+
+const dotenv = _utils.Import.lazy('dotenv', require);
+
+const tsConfigutils = _utils.Import.lazy('../utils/tsconfig', require);
+
+const valid = _utils.Import.lazy('../utils/valide', require);
+
+const dev = async option => {
+  const {
+    tsconfig: tsconfigName
+  } = option;
+  const appContext = core.useAppContext().value;
+  const modernConfig = core.useResolvedConfigContext().value;
+  const {
+    appDirectory
+  } = appContext;
+  const tsconfigPath = path.join(appDirectory, tsconfigName);
+  dotenv.config();
+  valid.valideBeforeTask({
+    modernConfig,
+    tsconfigPath
+  });
+  const isTsProject = tsConfigutils.existTsConfigFile(tsconfigPath); // await devFeature.showMenu({ isTsProject, appDirectory });
+
+  await devFeature.devStorybook({
+    isTsProject,
+    appDirectory
+  });
+};
+
+exports.dev = dev;