@cocojs/cli 0.0.1-alpha.0

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+declare function buildDotCoco(monorepoProjPath: string): void;
+
+export declare function cli(command: string, domain: string, rest: string[]): void;
+
+export declare let _test_helper: {
+    buildDotCoco: typeof buildDotCoco;
+};
+
+export { }

package/dist/index.js

@@ -0,0 +1,535 @@
+'use strict';
+
+var child_process = require('child_process');
+var path = require('path');
+var process$1 = require('node:process');
+var path$1 = require('node:path');
+var rollup = require('rollup');
+var typescript = require('@rollup/plugin-typescript');
+var babel = require('@rollup/plugin-babel');
+var cocojs = require('@cocojs/rollup-plugin-mvc');
+
+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 _arrayWithHoles(r) {
+  if (Array.isArray(r)) return r;
+}
+function asyncGeneratorStep(n, t, e, r, o, a, c) {
+  try {
+    var i = n[a](c),
+      u = i.value;
+  } catch (n) {
+    return void e(n);
+  }
+  i.done ? t(u) : Promise.resolve(u).then(r, o);
+}
+function _asyncToGenerator(n) {
+  return function () {
+    var t = this,
+      e = arguments;
+    return new Promise(function (r, o) {
+      var a = n.apply(t, e);
+      function _next(n) {
+        asyncGeneratorStep(a, r, o, _next, _throw, "next", n);
+      }
+      function _throw(n) {
+        asyncGeneratorStep(a, r, o, _next, _throw, "throw", n);
+      }
+      _next(void 0);
+    });
+  };
+}
+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 _defineProperty(e, r, t) {
+  return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, {
+    value: t,
+    enumerable: true,
+    configurable: true,
+    writable: true
+  }) : e[r] = t, e;
+}
+function _iterableToArrayLimit(r, l) {
+  var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"];
+  if (null != t) {
+    var e,
+      n,
+      i,
+      u,
+      a = [],
+      f = true,
+      o = false;
+    try {
+      if (i = (t = t.call(r)).next, 0 === l) ; else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0);
+    } catch (r) {
+      o = true, n = r;
+    } finally {
+      try {
+        if (!f && null != t.return && (u = t.return(), Object(u) !== u)) return;
+      } finally {
+        if (o) throw n;
+      }
+    }
+    return a;
+  }
+}
+function _nonIterableRest() {
+  throw new TypeError("Invalid attempt to destructure 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 _slicedToArray(r, e) {
+  return _arrayWithHoles(r) || _iterableToArrayLimit(r, e) || _unsupportedIterableToArray(r, e) || _nonIterableRest();
+}
+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 _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;
+  }
+}
+
+var WorkFlow = /*#__PURE__*/function () {
+  function WorkFlow() {
+    _classCallCheck(this, WorkFlow);
+    _defineProperty(this, "webpackProcess", void 0);
+    _defineProperty(this, "buildDotCocoProcess", void 0);
+    _defineProperty(this, "processingTask", void 0);
+    _defineProperty(this, "resolve", void 0);
+    _defineProperty(this, "reject", void 0);
+    this.init();
+  }
+  return _createClass(WorkFlow, [{
+    key: "init",
+    value: function init() {
+      var _this = this;
+      process$1.on('exit', function () {
+        _this.terminate();
+      });
+    }
+  }, {
+    key: "forkAll",
+    value: function forkAll() {
+      this.webpackProcess = this.startProcess(path.join(__dirname, './webpack-process/index.js'));
+      this.webpackProcess.on('message', this.webpackMessageCb.bind(this));
+      this.buildDotCocoProcess = this.startProcess(path.join(__dirname, './build-dot-coco-process/index.js'));
+      this.buildDotCocoProcess.on('message', this.buildDotCocoMessageCb.bind(this));
+    }
+  }, {
+    key: "startProcess",
+    value: function startProcess(entry) {
+      var _this2 = this;
+      var cp = child_process.fork(entry, ['run-as-process']);
+      cp.on('exit', function (code) {
+        _this2.terminate();
+      });
+      return cp;
+    }
+  }, {
+    key: "buildDotCocoMessageCb",
+    value: function buildDotCocoMessageCb(msg) {
+      switch (msg) {
+        case 'build-success':
+          if (!this.webpackProcess.killed) {
+            this.webpackProcess.send('build-once');
+          }
+          break;
+        case 'init-build-success':
+          if (!this.webpackProcess.killed) {
+            this.webpackProcess.send('start-server');
+          }
+          break;
+        default:
+          console.info('rcv msg from buildDotCoco process', msg);
+          break;
+      }
+    }
+  }, {
+    key: "webpackMessageCb",
+    value: function webpackMessageCb(msg) {
+      var _this$resolve;
+      switch (msg) {
+        case 'build-success':
+          (_this$resolve = this.resolve) === null || _this$resolve === void 0 || _this$resolve.call(this);
+          break;
+        default:
+          console.info('rcv msg from webpack process', msg);
+          break;
+      }
+    }
+  }, {
+    key: "build",
+    value: function () {
+      var _build = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee() {
+        return _regenerator().w(function (_context) {
+          while (1) switch (_context.n) {
+            case 0:
+              return _context.a(2, this.run('build-once'));
+          }
+        }, _callee, this);
+      }));
+      function build() {
+        return _build.apply(this, arguments);
+      }
+      return build;
+    }()
+  }, {
+    key: "dev",
+    value: function () {
+      var _dev = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee2() {
+        return _regenerator().w(function (_context2) {
+          while (1) switch (_context2.n) {
+            case 0:
+              return _context2.a(2, this.run('build-and-watch'));
+          }
+        }, _callee2, this);
+      }));
+      function dev() {
+        return _dev.apply(this, arguments);
+      }
+      return dev;
+    }()
+  }, {
+    key: "run",
+    value: function () {
+      var _run = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee3(task) {
+        var _this3 = this;
+        return _regenerator().w(function (_context3) {
+          while (1) switch (_context3.n) {
+            case 0:
+              if (!this.processingTask) {
+                _context3.n = 1;
+                break;
+              }
+              throw new Error('已经存在一个任务');
+            case 1:
+              this.buildDotCocoProcess.send(task);
+              this.processingTask = new Promise(function (resolve, reject) {
+                _this3.resolve = resolve;
+                _this3.reject = reject;
+              });
+              return _context3.a(2, this.processingTask);
+          }
+        }, _callee3, this);
+      }));
+      function run(_x) {
+        return _run.apply(this, arguments);
+      }
+      return run;
+    }()
+  }, {
+    key: "terminate",
+    value: function terminate() {
+      if (this.webpackProcess && !this.webpackProcess.killed) {
+        this.webpackProcess.kill();
+      }
+      if (this.buildDotCocoProcess && !this.buildDotCocoProcess.killed) {
+        this.buildDotCocoProcess.kill();
+      }
+    }
+  }]);
+}();
+
+function devApp() {
+  return _devApp.apply(this, arguments);
+}
+function _devApp() {
+  _devApp = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee() {
+    var workflow;
+    return _regenerator().w(function (_context) {
+      while (1) switch (_context.n) {
+        case 0:
+          workflow = new WorkFlow();
+          workflow.forkAll();
+          _context.n = 1;
+          return workflow.dev();
+        case 1:
+          return _context.a(2);
+      }
+    }, _callee);
+  }));
+  return _devApp.apply(this, arguments);
+}
+
+function buildApp() {
+  return _buildApp.apply(this, arguments);
+}
+function _buildApp() {
+  _buildApp = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee() {
+    var workFlow;
+    return _regenerator().w(function (_context) {
+      while (1) switch (_context.n) {
+        case 0:
+          workFlow = new WorkFlow();
+          workFlow.forkAll();
+          _context.n = 1;
+          return workFlow.build();
+        case 1:
+          process.exit(0);
+        case 2:
+          return _context.a(2);
+      }
+    }, _callee);
+  }));
+  return _buildApp.apply(this, arguments);
+}
+
+var build = /*#__PURE__*/function () {
+  var _ref = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee() {
+    var result;
+    return _regenerator().w(function (_context) {
+      while (1) switch (_context.n) {
+        case 0:
+          _context.n = 1;
+          return rollup.rollup({
+            input: path$1.join(process$1.cwd(), './src/index.ts'),
+            plugins: [cocojs(), typescript({
+              compilerOptions: {
+                target: 'ESNext',
+                lib: ['dom', 'esnext'],
+                declaration: true,
+                declarationDir: './dist/types',
+                jsx: 'preserve',
+                resolveJsonModule: true,
+                plugins: [{
+                  transform: '@cocojs/type-extractor',
+                  transformProgram: true
+                }]
+              }
+            }), babel({
+              extensions: ['.js', '.jsx', '.ts', '.tsx'],
+              plugins: [[require.resolve('@babel/plugin-proposal-decorators'), {
+                version: '2023-11'
+              }], [require.resolve('@babel/plugin-transform-react-jsx', {
+                paths: [path$1.resolve(__dirname, '..', '../node_modules')]
+              }), {
+                runtime: 'automatic',
+                importSource: '@cocojs/mvc'
+              }]]
+            })]
+          });
+        case 1:
+          result = _context.v;
+          _context.n = 2;
+          return result.write({
+            file: path$1.join(process$1.cwd(), './dist/index.esm.js'),
+            format: 'es'
+          });
+        case 2:
+          return _context.a(2);
+      }
+    }, _callee);
+  }));
+  return function build() {
+    return _ref.apply(this, arguments);
+  };
+}();
+
+var _test_helper;
+
+/**
+ * 应用项目命令
+ * coco app build 构建
+ * coco app dev 开发
+ */
+function execAppCmd(action) {
+  switch (action) {
+    case 'build':
+      {
+        buildApp();
+        break;
+      }
+    case 'dev':
+      {
+        devApp();
+        break;
+      }
+    default:
+      {
+        console.log("Unknown app action: ".concat(action));
+        break;
+      }
+  }
+}
+/**
+ * 组件库项目命令
+ * coco lib build 构建
+ */
+function execLibCmd(action) {
+  switch (action) {
+    case 'build':
+      {
+        build();
+        break;
+      }
+    case 'dev':
+      {
+        devApp();
+        break;
+      }
+    default:
+      {
+        console.log("Unknown lib action: ".concat(action));
+        break;
+      }
+  }
+}
+function cli(command, domain, rest) {
+  var _rest = _slicedToArray(rest, 1),
+    action = _rest[0];
+  switch (domain) {
+    case 'app':
+      {
+        execAppCmd(action);
+        break;
+      }
+    case 'lib':
+      {
+        execLibCmd(action);
+        break;
+      }
+    default:
+      {
+        console.log("Unknown domain: ".concat(domain));
+        break;
+      }
+  }
+}
+
+exports._test_helper = _test_helper;
+exports.cli = cli;