@cocojs/cli 0.0.1-alpha202511021451

package/dist/build-dot-coco-process/index.js

@@ -0,0 +1,822 @@
+'use strict';
+
+var process$1 = require('node:process');
+var fs = require('fs');
+var fse = require('fs-extra');
+var path$1 = require('path');
+var path = require('node:path');
+var parser = require('@babel/parser');
+var traverse = require('@babel/traverse');
+var types = require('@babel/types');
+var chokidar = require('chokidar');
+
+function _interopNamespaceDefault(e) {
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var process__namespace = /*#__PURE__*/_interopNamespaceDefault(process$1);
+var fs__namespace = /*#__PURE__*/_interopNamespaceDefault(fs);
+var path__namespace = /*#__PURE__*/_interopNamespaceDefault(path$1);
+
+function _arrayLikeToArray(r, a) {
+  (null == a || a > r.length) && (a = r.length);
+  for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e];
+  return n;
+}
+function _arrayWithoutHoles(r) {
+  if (Array.isArray(r)) return _arrayLikeToArray(r);
+}
+function _classCallCheck(a, n) {
+  if (!(a instanceof n)) throw new TypeError("Cannot call a class as a function");
+}
+function _defineProperties(e, r) {
+  for (var t = 0; t < r.length; t++) {
+    var o = r[t];
+    o.enumerable = o.enumerable || false, o.configurable = true, "value" in o && (o.writable = true), Object.defineProperty(e, _toPropertyKey(o.key), o);
+  }
+}
+function _createClass(e, r, t) {
+  return r && _defineProperties(e.prototype, r), Object.defineProperty(e, "prototype", {
+    writable: false
+  }), e;
+}
+function _createForOfIteratorHelper(r, e) {
+  var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"];
+  if (!t) {
+    if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e) {
+      t && (r = t);
+      var n = 0,
+        F = function () {};
+      return {
+        s: F,
+        n: function () {
+          return n >= r.length ? {
+            done: true
+          } : {
+            done: false,
+            value: r[n++]
+          };
+        },
+        e: function (r) {
+          throw r;
+        },
+        f: F
+      };
+    }
+    throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+  }
+  var o,
+    a = true,
+    u = false;
+  return {
+    s: function () {
+      t = t.call(r);
+    },
+    n: function () {
+      var r = t.next();
+      return a = r.done, r;
+    },
+    e: function (r) {
+      u = true, o = r;
+    },
+    f: function () {
+      try {
+        a || null == t.return || t.return();
+      } finally {
+        if (u) throw o;
+      }
+    }
+  };
+}
+function _iterableToArray(r) {
+  if ("undefined" != typeof Symbol && null != r[Symbol.iterator] || null != r["@@iterator"]) return Array.from(r);
+}
+function _nonIterableSpread() {
+  throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _regenerator() {
+  /*! regenerator-runtime -- Copyright (c) 2014-present, Facebook, Inc. -- license (MIT): https://github.com/babel/babel/blob/main/packages/babel-helpers/LICENSE */
+  var e,
+    t,
+    r = "function" == typeof Symbol ? Symbol : {},
+    n = r.iterator || "@@iterator",
+    o = r.toStringTag || "@@toStringTag";
+  function i(r, n, o, i) {
+    var c = n && n.prototype instanceof Generator ? n : Generator,
+      u = Object.create(c.prototype);
+    return _regeneratorDefine(u, "_invoke", function (r, n, o) {
+      var i,
+        c,
+        u,
+        f = 0,
+        p = o || [],
+        y = false,
+        G = {
+          p: 0,
+          n: 0,
+          v: e,
+          a: d,
+          f: d.bind(e, 4),
+          d: function (t, r) {
+            return i = t, c = 0, u = e, G.n = r, a;
+          }
+        };
+      function d(r, n) {
+        for (c = r, u = n, t = 0; !y && f && !o && t < p.length; t++) {
+          var o,
+            i = p[t],
+            d = G.p,
+            l = i[2];
+          r > 3 ? (o = l === n) && (u = i[(c = i[4]) ? 5 : (c = 3, 3)], i[4] = i[5] = e) : i[0] <= d && ((o = r < 2 && d < i[1]) ? (c = 0, G.v = n, G.n = i[1]) : d < l && (o = r < 3 || i[0] > n || n > l) && (i[4] = r, i[5] = n, G.n = l, c = 0));
+        }
+        if (o || r > 1) return a;
+        throw y = true, n;
+      }
+      return function (o, p, l) {
+        if (f > 1) throw TypeError("Generator is already running");
+        for (y && 1 === p && d(p, l), c = p, u = l; (t = c < 2 ? e : u) || !y;) {
+          i || (c ? c < 3 ? (c > 1 && (G.n = -1), d(c, u)) : G.n = u : G.v = u);
+          try {
+            if (f = 2, i) {
+              if (c || (o = "next"), t = i[o]) {
+                if (!(t = t.call(i, u))) throw TypeError("iterator result is not an object");
+                if (!t.done) return t;
+                u = t.value, c < 2 && (c = 0);
+              } else 1 === c && (t = i.return) && t.call(i), c < 2 && (u = TypeError("The iterator does not provide a '" + o + "' method"), c = 1);
+              i = e;
+            } else if ((t = (y = G.n < 0) ? u : r.call(n, G)) !== a) break;
+          } catch (t) {
+            i = e, c = 1, u = t;
+          } finally {
+            f = 1;
+          }
+        }
+        return {
+          value: t,
+          done: y
+        };
+      };
+    }(r, o, i), true), u;
+  }
+  var a = {};
+  function Generator() {}
+  function GeneratorFunction() {}
+  function GeneratorFunctionPrototype() {}
+  t = Object.getPrototypeOf;
+  var c = [][n] ? t(t([][n]())) : (_regeneratorDefine(t = {}, n, function () {
+      return this;
+    }), t),
+    u = GeneratorFunctionPrototype.prototype = Generator.prototype = Object.create(c);
+  function f(e) {
+    return Object.setPrototypeOf ? Object.setPrototypeOf(e, GeneratorFunctionPrototype) : (e.__proto__ = GeneratorFunctionPrototype, _regeneratorDefine(e, o, "GeneratorFunction")), e.prototype = Object.create(u), e;
+  }
+  return GeneratorFunction.prototype = GeneratorFunctionPrototype, _regeneratorDefine(u, "constructor", GeneratorFunctionPrototype), _regeneratorDefine(GeneratorFunctionPrototype, "constructor", GeneratorFunction), GeneratorFunction.displayName = "GeneratorFunction", _regeneratorDefine(GeneratorFunctionPrototype, o, "GeneratorFunction"), _regeneratorDefine(u), _regeneratorDefine(u, o, "Generator"), _regeneratorDefine(u, n, function () {
+    return this;
+  }), _regeneratorDefine(u, "toString", function () {
+    return "[object Generator]";
+  }), (_regenerator = function () {
+    return {
+      w: i,
+      m: f
+    };
+  })();
+}
+function _regeneratorDefine(e, r, n, t) {
+  var i = Object.defineProperty;
+  try {
+    i({}, "", {});
+  } catch (e) {
+    i = 0;
+  }
+  _regeneratorDefine = function (e, r, n, t) {
+    function o(r, n) {
+      _regeneratorDefine(e, r, function (e) {
+        return this._invoke(r, n, e);
+      });
+    }
+    r ? i ? i(e, r, {
+      value: n,
+      enumerable: !t,
+      configurable: !t,
+      writable: !t
+    }) : e[r] = n : (o("next", 0), o("throw", 1), o("return", 2));
+  }, _regeneratorDefine(e, r, n, t);
+}
+function _toConsumableArray(r) {
+  return _arrayWithoutHoles(r) || _iterableToArray(r) || _unsupportedIterableToArray(r) || _nonIterableSpread();
+}
+function _toPrimitive(t, r) {
+  if ("object" != typeof t || !t) return t;
+  var e = t[Symbol.toPrimitive];
+  if (void 0 !== e) {
+    var i = e.call(t, r);
+    if ("object" != typeof i) return i;
+    throw new TypeError("@@toPrimitive must return a primitive value.");
+  }
+  return (String )(t);
+}
+function _toPropertyKey(t) {
+  var i = _toPrimitive(t, "string");
+  return "symbol" == typeof i ? i : i + "";
+}
+function _typeof(o) {
+  "@babel/helpers - typeof";
+
+  return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) {
+    return typeof o;
+  } : function (o) {
+    return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o;
+  }, _typeof(o);
+}
+function _unsupportedIterableToArray(r, a) {
+  if (r) {
+    if ("string" == typeof r) return _arrayLikeToArray(r, a);
+    var t = {}.toString.call(r).slice(8, -1);
+    return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0;
+  }
+}
+
+function __awaiter(thisArg, _arguments, P, generator) {
+  function adopt(value) {
+    return value instanceof P ? value : new P(function (resolve) {
+      resolve(value);
+    });
+  }
+  return new (P || (P = Promise))(function (resolve, reject) {
+    function fulfilled(value) {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    }
+    function rejected(value) {
+      try {
+        step(generator["throw"](value));
+      } catch (e) {
+        reject(e);
+      }
+    }
+    function step(result) {
+      result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
+    }
+    step((generator = generator.apply(thisArg, _arguments || [])).next());
+  });
+}
+typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+  var e = new Error(message);
+  return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+};
+
+var Project = /*#__PURE__*/function () {
+  function Project(projectPath) {
+    var _this = this;
+    _classCallCheck(this, Project);
+    // 项目所在文件夹的绝对路径
+    this.absPath = '';
+    this.genFullPath = function (name) {
+      return path.join(_this.srcAbsPath, name);
+    };
+    this.absPath = path.join(process.cwd(), projectPath);
+  }
+  return _createClass(Project, [{
+    key: "srcAbsPath",
+    get: function get() {
+      return path.join(this.absPath, "src");
+    }
+  }, {
+    key: "propertiesAbsPath",
+    get: function get() {
+      return path.join(this.absPath, "properties");
+    }
+  }, {
+    key: "dotCocoAbsPath",
+    get: function get() {
+      return path.join(this.srcAbsPath, Project.DOT_COCO_DIR);
+    }
+  }, {
+    key: "applicationTsFileAbsPath",
+    get: function get() {
+      return path.join(this.srcAbsPath, Project.APPLICATION);
+    }
+  }]);
+}();
+Project.DOT_COCO_DIR = '.coco';
+Project.APPLICATION = 'application.ts';
+Project.VIEW_DIR = 'view';
+Project.CONFIG_DIR = 'config';
+Project.PAGE_DIR = 'page';
+Project.LAYOUT_DIR = 'layout';
+Project.Flow_DIR = 'flow';
+Project.API_DIR = 'api';
+Project.STORE_DIR = 'store';
+Project.GLOBAL_DATA_DIR = 'global-data';
+Project.COMPONENTS_DIR = 'component';
+
+/**
+ * 构建.coco文件夹
+ */
+function genIndexTsx(project, iocComponents) {
+  // 2. 生成.coco文件
+  var importStatements = iocComponents.map(function (_ref) {
+    var className = _ref.className,
+      filePath = _ref.filePath;
+    var relativePath = path$1.relative(project.dotCocoAbsPath, filePath);
+    var extLen = path$1.extname(relativePath).length;
+    var relativePathNoExt = relativePath.slice(0, relativePath.length - extLen);
+    return "export { default as ".concat(className, " } from '").concat(relativePathNoExt, "';");
+  });
+  var dotCocoDir = project.genFullPath(Project.DOT_COCO_DIR);
+  fse.ensureDirSync(dotCocoDir);
+  fs.writeFileSync(path$1.join(dotCocoDir, 'index.tsx'), appendExport(importStatements), {
+    encoding: 'utf-8'
+  });
+}
+function appendExport(importStatements) {
+  var pre = "";
+  var append = "\nimport { Application } from \"coco-mvc\";\nimport applicationJson from \"./application.json\";\nexport { Application };\n\n".concat(process__namespace.env.NODE_ENV === 'test' ? "\n// \u6D4B\u8BD5\u65F6\u7531\u6D4B\u8BD5\u7528\u4F8B\u542F\u52A8Application\n" : "\nconst application = new Application(applicationJson);\napplication.start();\n    ", "\n  ");
+  return pre.concat(importStatements.join('\n')).concat(append);
+}
+
+var cmdDefaultEnvMap = {
+  dev: 'dev',
+  build: 'prod'
+};
+var defaultPropertiesName = 'application.json';
+/**
+ * 综合NODE_ENV和命令得到运行时配置文件名
+ * 如果有NODE_ENV，则返回
+ * 如果没有，则考虑dev和build默认设定
+ */
+var propertiesFileName = function propertiesFileName(cmd) {
+  var env = process$1.env.NODE_ENV || cmdDefaultEnvMap[cmd] || '';
+  return env ? "application.".concat(env, ".json") : defaultPropertiesName;
+};
+
+function readFile(filepath) {
+  var content = '{}';
+  if (fs.existsSync(filepath)) {
+    content = fs.readFileSync(filepath, 'utf8');
+  }
+  return content;
+}
+function merge(project, cmd) {
+  var defaultConfigStr = readFile(path$1.join(project.absPath, "properties/".concat(defaultPropertiesName)));
+  var envConfigStr = readFile(path$1.join(project.absPath, "properties/".concat(propertiesFileName(cmd))));
+  var defaultConfig = {};
+  try {
+    defaultConfig = JSON.parse(defaultConfigStr);
+  } catch (error) {
+    // 写了一半的配置文件
+  }
+  var envConfig = {};
+  try {
+    envConfig = JSON.parse(envConfigStr);
+  } catch (error) {
+    // 写了一半的配置文件
+  }
+  var config = merge2properties(defaultConfig, envConfig);
+  var filePath = path$1.join(project.absPath, 'src/.coco/application.json');
+  fs.writeFileSync(filePath, JSON.stringify(config, null, 2), {
+    encoding: 'utf-8'
+  });
+}
+// 从前往后依次合并配置对象
+function merge2properties() {
+  for (var _len = arguments.length, configs = new Array(_len), _key = 0; _key < _len; _key++) {
+    configs[_key] = arguments[_key];
+  }
+  if (configs.length === 0) {
+    return {};
+  }
+  return configs.reduce(function (prev, currentConfig) {
+    return doMerge(prev, currentConfig);
+  });
+}
+function doMerge(config1, config2) {
+  var type1 = _typeof(config1);
+  var type2 = _typeof(config2);
+  if (type1 !== type2) {
+    return config2;
+  } else if (type2 === 'string' || type2 === 'boolean' || type2 === 'number' || config2 === null || Array.isArray(config2)) {
+    return config2;
+  }
+  var keys2 = Object.keys(config2);
+  var merged = Object.assign({}, config1);
+  for (var _i = 0, _keys = keys2; _i < _keys.length; _i++) {
+    var key = _keys[_i];
+    merged[key] = doMerge(config1[key], config2[key]);
+  }
+  return merged;
+}
+
+// console.log(numberToLetter(0));  // A
+// console.log(numberToLetter(1));  // B
+// console.log(numberToLetter(25)); // Z
+// console.log(numberToLetter(26)); // AA
+// console.log(numberToLetter(27)); // AB
+// console.log(numberToLetter(51)); // AZ
+// console.log(numberToLetter(52)); // BA
+function numberToLetter(n) {
+  var result = '';
+  while (n >= 0) {
+    result = String.fromCharCode(n % 26 + 65) + result;
+    n = Math.floor(n / 26) - 1;
+    if (n < 0) break;
+  }
+  return result;
+}
+
+var PATH_TYPE;
+(function (PATH_TYPE) {
+  PATH_TYPE[PATH_TYPE["FOLDER"] = 0] = "FOLDER";
+  PATH_TYPE[PATH_TYPE["FILE"] = 1] = "FILE";
+})(PATH_TYPE || (PATH_TYPE = {}));
+var number = 0;
+var RE_DEFAULT_EXPORT = /export\s+default\s+(\w+);?\s?/;
+function scanOneFile(filePath, decorator) {
+  var content = fs__namespace.readFileSync(filePath, 'utf-8');
+  if (content.includes(decorator) && RE_DEFAULT_EXPORT.test(content)) {
+    // todo 需要校验export出来的class名称和注解的是否一致
+    // const className = RE_DEFAULT_EXPORT.exec(content)[1];
+    return {
+      className: numberToLetter(number++),
+      filePath: filePath
+    };
+  }
+  return null;
+}
+function doScan(type, _path, fileExt, decorator) {
+  var result = [];
+  if (!fs__namespace.existsSync(_path)) {
+    return result;
+  }
+  if (type === PATH_TYPE.FOLDER) {
+    var files = fs__namespace.readdirSync(_path);
+    var _iterator = _createForOfIteratorHelper(files),
+      _step;
+    try {
+      for (_iterator.s(); !(_step = _iterator.n()).done;) {
+        var file = _step.value;
+        var filePath = path__namespace.join(_path, file);
+        var stat = fs__namespace.statSync(filePath);
+        if (stat.isDirectory()) {
+          var find = doScan(PATH_TYPE.FOLDER, filePath, fileExt, decorator);
+          if (find.length) {
+            result.push.apply(result, _toConsumableArray(find));
+          }
+        } else if (stat.isFile() && path__namespace.extname(filePath) === fileExt) {
+          var r = scanOneFile(filePath, decorator);
+          if (r) {
+            result.push(r);
+          }
+        }
+      }
+    } catch (err) {
+      _iterator.e(err);
+    } finally {
+      _iterator.f();
+    }
+  } else if (type === PATH_TYPE.FILE) {
+    var _r = scanOneFile(_path, decorator);
+    if (_r) {
+      result.push(_r);
+    }
+  }
+  return result;
+}
+var scanPathConfig = [{
+  // 配置项
+  type: PATH_TYPE.FOLDER,
+  path: Project.CONFIG_DIR,
+  fileExt: '.ts',
+  decorator: '@configuration'
+}, {
+  // 布局
+  type: PATH_TYPE.FOLDER,
+  path: Project.LAYOUT_DIR,
+  fileExt: '.tsx',
+  decorator: '@layout'
+}, {
+  // 页面
+  type: PATH_TYPE.FOLDER,
+  path: Project.PAGE_DIR,
+  fileExt: '.tsx',
+  decorator: '@page'
+}, {
+  // 控制器
+  type: PATH_TYPE.FOLDER,
+  path: Project.Flow_DIR,
+  fileExt: '.ts',
+  decorator: '@flow'
+}, {
+  // 通用组件
+  type: PATH_TYPE.FOLDER,
+  path: Project.COMPONENTS_DIR,
+  fileExt: '.ts',
+  decorator: '@component'
+}, {
+  // 接口
+  type: PATH_TYPE.FOLDER,
+  path: Project.API_DIR,
+  fileExt: '.ts',
+  decorator: '@api'
+}, {
+  // 视图
+  type: PATH_TYPE.FOLDER,
+  path: Project.VIEW_DIR,
+  fileExt: '.tsx',
+  decorator: '@view'
+}, {
+  // 全局数据
+  type: PATH_TYPE.FOLDER,
+  path: Project.GLOBAL_DATA_DIR,
+  fileExt: '.ts',
+  decorator: '@globalData'
+}, {
+  // 全局状态
+  type: PATH_TYPE.FOLDER,
+  path: Project.STORE_DIR,
+  fileExt: '.ts',
+  decorator: '@store'
+}, {
+  // 入口文件
+  type: PATH_TYPE.FILE,
+  path: Project.APPLICATION,
+  fileExt: '.ts',
+  decorator: '@webApplication'
+}];
+var scan = function scan(project) {
+  return scanPathConfig.reduce(function (prev, curr) {
+    prev.push.apply(prev, _toConsumableArray(doScan(curr.type, project.genFullPath(curr.path), curr.fileExt, curr.decorator)));
+    return prev;
+  }, []);
+};
+
+function validateConstructor(project) {
+  // 1. 扫描所有ioc组件
+  var iocComponents = scan(project);
+  // 2. 生成.coco文件
+  var importStatements = iocComponents.map(function (_ref) {
+    _ref.className;
+      var filePath = _ref.filePath;
+    return filePath;
+  });
+  var _iterator = _createForOfIteratorHelper(importStatements),
+    _step;
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var filePath = _step.value;
+      validate(filePath);
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+}
+function validate(filePath) {
+  var inputCode = fs.readFileSync(filePath, 'utf-8');
+  var ast = parser.parse(inputCode, {
+    sourceType: 'module',
+    plugins: ['jsx', 'typescript', 'decorators-legacy', 'classProperties']
+  });
+  traverse["default"](ast, {
+    ClassDeclaration: function ClassDeclaration(path) {
+      var body = path.node.body.body;
+      body.forEach(function (method) {
+        if (method.kind === 'constructor') {
+          var statements = method.body.body;
+          statements.forEach(function (statement) {
+            if (types.isExpressionStatement(statement) && types.isCallExpression(statement.expression)) {
+              if (statement.expression.callee.type === 'Super') {
+                return;
+              }
+              var fnName;
+              if (statement.expression.callee.type === 'MemberExpression') {
+                // todo fix it
+                // @ts-ignore
+                fnName = statement.expression.callee.property.name;
+              } else if (statement.expression.callee.type === 'Identifier') {
+                fnName = statement.expression.callee.name;
+              } else {
+                console.warn('未知函数调用类型', statement.expression.callee);
+                fnName = JSON.stringify(statement.expression.callee);
+              }
+              throw new Error("\u4E0D\u5141\u8BB8\u5728\u6784\u9020\u51FD\u6570\u5185\u6267\u884C\u51FD\u6570\u8C03\u7528\u3010".concat(fnName, "\u3011\u3002"));
+            }
+          });
+        }
+      });
+    }
+  });
+}
+
+var DotCocoBuilder = /*#__PURE__*/_createClass(
+/**
+ * 目前仅支持单体应用，为了单元测试，可以传入子应用相对项目根的路径
+ * @param monorepoPath
+ */
+function DotCocoBuilder() {
+  var _this = this;
+  var monorepoPath = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '.';
+  _classCallCheck(this, DotCocoBuilder);
+  this.ensureEmptyDotCocoFolder = function (project) {
+    if (fs.existsSync(project.dotCocoAbsPath)) {
+      fs.rmSync(project.dotCocoAbsPath, {
+        recursive: true
+      });
+    }
+    fs.mkdirSync(project.dotCocoAbsPath);
+  };
+  /**
+   * 完成构建前的准备工作
+   */
+  this.build = function () {
+    _this.ensureEmptyDotCocoFolder(_this.project);
+    validateConstructor(_this.project);
+    merge(_this.project, _this.cmd);
+    genIndexTsx(_this.project, _this.iocComponents);
+  };
+  this.isTsTsxFile = function (path) {
+    return path.endsWith('.ts') || path.endsWith('.tsx');
+  };
+  this.handleAddFile = function (filePath) {
+    if (_this.isTsTsxFile(filePath)) {
+      var _path$parse = path.parse(filePath),
+        dir = _path$parse.dir,
+        ext = _path$parse.ext;
+      var match = scanPathConfig.find(function (item) {
+        return dir.startsWith(item.path) && item.fileExt === ext;
+      });
+      if (!match) {
+        return;
+      }
+      var scanRlt = scanOneFile(_this.project.genFullPath(filePath), match.decorator);
+      if (scanRlt !== null) {
+        if (!_this.iocComponents.find(function (i) {
+          return i.filePath === scanRlt.filePath;
+        })) {
+          // 新增一个组件
+          _this.iocComponents.push(scanRlt);
+          genIndexTsx(_this.project, _this.iocComponents);
+        }
+      }
+    }
+  };
+  this.handleDeleteFile = function (filePath) {
+    if (_this.isTsTsxFile(filePath)) {
+      var fullPath = _this.project.genFullPath(filePath);
+      var index = _this.iocComponents.findIndex(function (i) {
+        return i.filePath === fullPath;
+      });
+      if (index > 0) {
+        _this.iocComponents.splice(index, 1);
+        genIndexTsx(_this.project, _this.iocComponents);
+      }
+    }
+  };
+  this.watchSrc = function () {
+    _this.srcWatcher = chokidar.watch(_this.project.srcAbsPath, {
+      ignored: function ignored(absPath, stats) {
+        // 忽略.coco文件夹
+        var srcPath = path.relative(_this.project.srcAbsPath, absPath);
+        return srcPath.startsWith('.coco');
+      },
+      ignoreInitial: true,
+      cwd: _this.project.srcAbsPath
+    });
+    _this.srcWatcher.on('add', _this.handleAddFile);
+    _this.srcWatcher.on('change', _this.handleAddFile);
+    _this.srcWatcher.on('unlink', _this.handleDeleteFile);
+  };
+  this.watchProperties = function () {
+    _this.propertiesWatcher = chokidar.watch(_this.project.propertiesAbsPath, {
+      ignored: function ignored(absPath, stats) {
+        var filename = path.relative(_this.project.propertiesAbsPath, absPath);
+        if (absPath === _this.project.propertiesAbsPath || filename === defaultPropertiesName || filename === propertiesFileName(_this.cmd)) {
+          return false;
+        }
+        return true;
+      },
+      ignoreInitial: true,
+      cwd: _this.project.srcAbsPath
+    });
+    _this.propertiesWatcher.on('add', function () {
+      return merge(_this.project, _this.cmd);
+    });
+    _this.propertiesWatcher.on('change', function () {
+      return merge(_this.project, _this.cmd);
+    });
+    _this.propertiesWatcher.on('unlink', function () {
+      return merge(_this.project, _this.cmd);
+    });
+  };
+  this.startWatch = function () {
+    _this.watchSrc();
+    _this.watchProperties();
+  };
+  this.stopWatch = function () {
+    return __awaiter(_this, void 0, void 0, /*#__PURE__*/_regenerator().m(function _callee() {
+      return _regenerator().w(function (_context) {
+        while (1) switch (_context.n) {
+          case 0:
+            if (!this.srcWatcher) {
+              _context.n = 2;
+              break;
+            }
+            _context.n = 1;
+            return this.srcWatcher.close();
+          case 1:
+            this.srcWatcher = null;
+          case 2:
+            if (!this.propertiesWatcher) {
+              _context.n = 4;
+              break;
+            }
+            _context.n = 3;
+            return this.propertiesWatcher.close();
+          case 3:
+            this.propertiesWatcher = null;
+          case 4:
+            return _context.a(2);
+        }
+      }, _callee, this);
+    }));
+  };
+  this.project = new Project(monorepoPath);
+  this.iocComponents = scan(this.project);
+});
+
+function startListening(builder) {
+  var watching = false;
+  process$1.on('message', function (msg) {
+    switch (msg) {
+      case 'build-once':
+        {
+          builder.build();
+          process$1.send('build-success');
+          break;
+        }
+      case 'build-and-watch':
+        {
+          builder.build();
+          process$1.send('init-build-success');
+          watching = true;
+          builder.startWatch();
+          break;
+        }
+      default:
+        {
+          process$1.send("dot coco process rcv msg:[".concat(msg, "]"));
+          break;
+        }
+    }
+  });
+  function handleTerminate() {
+    return __awaiter(this, void 0, void 0, /*#__PURE__*/_regenerator().m(function _callee() {
+      return _regenerator().w(function (_context) {
+        while (1) switch (_context.n) {
+          case 0:
+            if (!watching) {
+              _context.n = 2;
+              break;
+            }
+            _context.n = 1;
+            return builder.stopWatch();
+          case 1:
+            watching = false;
+          case 2:
+            process$1.exit(0);
+          case 3:
+            return _context.a(2);
+        }
+      }, _callee);
+    }));
+  }
+  process$1.on('SIGTERM', handleTerminate);
+  process$1.on('SIGINT', handleTerminate);
+}
+function startAsProcess() {
+  var secondArgv = process$1.argv[2];
+  if (secondArgv === 'run-as-process') {
+    var builder = new DotCocoBuilder();
+    startListening(builder);
+  }
+}
+startAsProcess();
+
+module.exports = DotCocoBuilder;