@modern-js/server 2.15.1-alpha.0 → 2.17.0

package/dist/esm/dev-tools/register/index.js

@@ -1,155 +1,155 @@
-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;
+function _define_property(obj, key, value) {
+  if (key in obj) {
+    Object.defineProperty(obj, key, {
+      value,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  } else {
+    obj[key] = value;
+  }
+  return obj;
 }
-function _objectSpread(target) {
-    for(var i = 1; i < arguments.length; i++){
-        var source = arguments[i] != null ? arguments[i] : {};
-        var ownKeys = Object.keys(source);
-        if (typeof Object.getOwnPropertySymbols === "function") {
-            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
-                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
-            }));
-        }
-        ownKeys.forEach(function(key) {
-            _defineProperty(target, key, source[key]);
-        });
+function _object_spread(target) {
+  for (var i = 1; i < arguments.length; i++) {
+    var source = arguments[i] != null ? arguments[i] : {};
+    var ownKeys2 = Object.keys(source);
+    if (typeof Object.getOwnPropertySymbols === "function") {
+      ownKeys2 = ownKeys2.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+        return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+      }));
     }
-    return target;
+    ownKeys2.forEach(function(key) {
+      _define_property(target, key, source[key]);
+    });
+  }
+  return target;
 }
 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);
+  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;
+      });
     }
-    return keys;
+    keys.push.apply(keys, symbols);
+  }
+  return keys;
 }
-function _objectSpreadProps(target, source) {
-    source = source != null ? source : {};
-    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 _object_spread_props(target, source) {
+  source = source != null ? source : {};
+  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;
 }
 import path from "path";
 import { resolveBabelConfig } from "@modern-js/server-utils";
 import { fs, getAliasConfig, createDebugger } from "@modern-js/utils";
 var debug = createDebugger("server");
 var checkDep = function(depName, paths) {
-    var packagePath = "";
-    try {
-        packagePath = require.resolve(depName, {
-            paths: paths
-        });
-    } catch (error) {}
-    return Boolean(packagePath);
+  var packagePath = "";
+  try {
+    packagePath = require.resolve(depName, {
+      paths
+    });
+  } catch (error) {
+  }
+  return Boolean(packagePath);
 };
-var enableRegister = function(projectRoot, config) {
-    var registerDirs = [
-        "./api",
-        "./server",
-        "./config/mock",
-        "./shared"
-    ];
-    var TS_CONFIG_FILENAME = "tsconfig.json";
-    var tsconfigPath = path.resolve(projectRoot, TS_CONFIG_FILENAME);
-    var isTsProject = fs.existsSync(tsconfigPath);
-    var existTsNode = checkDep("ts-node", [
-        projectRoot
-    ]);
-    var existTsConfigPaths = checkDep("tsconfig-paths", [
-        projectRoot
-    ]);
-    if (isTsProject && existTsNode && existTsConfigPaths) {
-        var _config_output_distPath;
-        debug("use ts-node");
-        var distPath = ((_config_output_distPath = config.output.distPath) === null || _config_output_distPath === void 0 ? void 0 : _config_output_distPath.root) || "dist";
-        var tsNode = require("ts-node");
-        var tsConfigPaths = require("tsconfig-paths");
-        var alias = config.source.alias;
-        var aliasConfig = getAliasConfig(alias, {
-            appDirectory: projectRoot,
-            tsconfigPath: tsconfigPath
-        });
-        var _aliasConfig_paths = aliasConfig.paths, paths = _aliasConfig_paths === void 0 ? {} : _aliasConfig_paths, _aliasConfig_absoluteBaseUrl = aliasConfig.absoluteBaseUrl, absoluteBaseUrl = _aliasConfig_absoluteBaseUrl === void 0 ? "./" : _aliasConfig_absoluteBaseUrl;
-        var tsPaths = Object.keys(paths).reduce(function(o, key) {
-            var tsPath = paths[key];
-            if (typeof tsPath === "string" && path.isAbsolute(tsPath)) {
-                tsPath = path.relative(absoluteBaseUrl, tsPath);
-            }
-            if (typeof tsPath === "string") {
-                tsPath = [
-                    tsPath
-                ];
-            }
-            return _objectSpreadProps(_objectSpread({}, o), _defineProperty({}, "".concat(key), tsPath));
-        }, {});
-        tsConfigPaths.register({
-            baseUrl: absoluteBaseUrl || "./",
-            paths: tsPaths
-        });
-        tsNode.register({
-            project: tsconfigPath,
-            scope: true,
-            // for env.d.ts, https://www.npmjs.com/package/ts-node#missing-types
-            files: true,
-            transpileOnly: true,
-            ignore: [
-                "(?:^|/)node_modules/",
-                "(?:^|/)".concat(distPath, "/")
-            ]
-        });
-    } else {
-        var _config_tools, _config_server;
-        debug("use @babel/register");
-        var babelConfig = resolveBabelConfig(projectRoot, _objectSpreadProps(_objectSpread({}, config.source), {
-            babelConfig: (_config_tools = config.tools) === null || _config_tools === void 0 ? void 0 : _config_tools.babel,
-            server: {
-                compiler: (_config_server = config.server) === null || _config_server === void 0 ? void 0 : _config_server.compiler
-            }
-        }), {
-            tsconfigPath: tsconfigPath,
-            syntax: "es6+",
-            type: "commonjs"
-        });
-        return require("@babel/register")(_objectSpreadProps(_objectSpread({}, babelConfig), {
-            only: [
-                function(filePath) {
-                    if (filePath.includes("node_modules".concat(path.sep, ".modern-js"))) {
-                        return true;
-                    }
-                    return registerDirs.some(function(registerDir) {
-                        return filePath.startsWith(path.join(projectRoot, registerDir));
-                    });
-                }
-            ],
-            extensions: [
-                ".js",
-                ".ts"
-            ],
-            babelrc: false,
-            configFile: false,
-            root: projectRoot
-        }));
-    }
+export var enableRegister = function(projectRoot, config) {
+  var registerDirs = [
+    "./api",
+    "./server",
+    "./config/mock",
+    "./shared"
+  ];
+  var TS_CONFIG_FILENAME = "tsconfig.json";
+  var tsconfigPath = path.resolve(projectRoot, TS_CONFIG_FILENAME);
+  var isTsProject = fs.existsSync(tsconfigPath);
+  var existTsNode = checkDep("ts-node", [
+    projectRoot
+  ]);
+  var existTsConfigPaths = checkDep("tsconfig-paths", [
+    projectRoot
+  ]);
+  if (isTsProject && existTsNode && existTsConfigPaths) {
+    var _config_output_distPath;
+    debug("use ts-node");
+    var distPath = ((_config_output_distPath = config.output.distPath) === null || _config_output_distPath === void 0 ? void 0 : _config_output_distPath.root) || "dist";
+    var tsNode = require("ts-node");
+    var tsConfigPaths = require("tsconfig-paths");
+    var alias = config.source.alias;
+    var aliasConfig = getAliasConfig(alias, {
+      appDirectory: projectRoot,
+      tsconfigPath
+    });
+    var _aliasConfig_paths = aliasConfig.paths, paths = _aliasConfig_paths === void 0 ? {} : _aliasConfig_paths, _aliasConfig_absoluteBaseUrl = aliasConfig.absoluteBaseUrl, absoluteBaseUrl = _aliasConfig_absoluteBaseUrl === void 0 ? "./" : _aliasConfig_absoluteBaseUrl;
+    var tsPaths = Object.keys(paths).reduce(function(o, key) {
+      var tsPath = paths[key];
+      if (typeof tsPath === "string" && path.isAbsolute(tsPath)) {
+        tsPath = path.relative(absoluteBaseUrl, tsPath);
+      }
+      if (typeof tsPath === "string") {
+        tsPath = [
+          tsPath
+        ];
+      }
+      return _object_spread_props(_object_spread({}, o), _define_property({}, "".concat(key), tsPath));
+    }, {});
+    tsConfigPaths.register({
+      baseUrl: absoluteBaseUrl || "./",
+      paths: tsPaths
+    });
+    tsNode.register({
+      project: tsconfigPath,
+      scope: true,
+      // for env.d.ts, https://www.npmjs.com/package/ts-node#missing-types
+      files: true,
+      transpileOnly: true,
+      ignore: [
+        "(?:^|/)node_modules/",
+        "(?:^|/)".concat(distPath, "/")
+      ]
+    });
+  } else {
+    var _config_tools, _config_server;
+    debug("use @babel/register");
+    var babelConfig = resolveBabelConfig(projectRoot, _object_spread_props(_object_spread({}, config.source), {
+      babelConfig: (_config_tools = config.tools) === null || _config_tools === void 0 ? void 0 : _config_tools.babel,
+      server: {
+        compiler: (_config_server = config.server) === null || _config_server === void 0 ? void 0 : _config_server.compiler
+      }
+    }), {
+      tsconfigPath,
+      syntax: "es6+",
+      type: "commonjs"
+    });
+    return require("@babel/register")(_object_spread_props(_object_spread({}, babelConfig), {
+      only: [
+        function(filePath) {
+          if (filePath.includes("node_modules".concat(path.sep, ".modern-js"))) {
+            return true;
+          }
+          return registerDirs.some(function(registerDir) {
+            return filePath.startsWith(path.join(projectRoot, registerDir));
+          });
+        }
+      ],
+      extensions: [
+        ".js",
+        ".ts"
+      ],
+      babelrc: false,
+      configFile: false,
+      root: projectRoot
+    }));
+  }
 };
-export { enableRegister };

package/dist/esm/dev-tools/watcher/dependencyTree.js

@@ -1,156 +1,171 @@
-function _arrayLikeToArray(arr, len) {
-    if (len == null || len > arr.length) len = arr.length;
-    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
-    return arr2;
+function _array_like_to_array(arr, len) {
+  if (len == null || len > arr.length)
+    len = arr.length;
+  for (var i = 0, arr2 = new Array(len); i < len; i++)
+    arr2[i] = arr[i];
+  return arr2;
 }
-function _arrayWithoutHoles(arr) {
-    if (Array.isArray(arr)) return _arrayLikeToArray(arr);
+function _array_without_holes(arr) {
+  if (Array.isArray(arr))
+    return _array_like_to_array(arr);
 }
-function _classCallCheck(instance, Constructor) {
-    if (!(instance instanceof Constructor)) {
-        throw new TypeError("Cannot call a class as a function");
-    }
+function _class_call_check(instance, Constructor) {
+  if (!(instance instanceof Constructor)) {
+    throw new TypeError("Cannot call a class as a function");
+  }
 }
 function _defineProperties(target, props) {
-    for(var i = 0; i < props.length; i++){
-        var descriptor = props[i];
-        descriptor.enumerable = descriptor.enumerable || false;
-        descriptor.configurable = true;
-        if ("value" in descriptor) descriptor.writable = true;
-        Object.defineProperty(target, descriptor.key, descriptor);
-    }
+  for (var i = 0; i < props.length; i++) {
+    var descriptor = props[i];
+    descriptor.enumerable = descriptor.enumerable || false;
+    descriptor.configurable = true;
+    if ("value" in descriptor)
+      descriptor.writable = true;
+    Object.defineProperty(target, descriptor.key, descriptor);
+  }
 }
-function _createClass(Constructor, protoProps, staticProps) {
-    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
-    if (staticProps) _defineProperties(Constructor, staticProps);
-    return Constructor;
+function _create_class(Constructor, protoProps, staticProps) {
+  if (protoProps)
+    _defineProperties(Constructor.prototype, protoProps);
+  if (staticProps)
+    _defineProperties(Constructor, staticProps);
+  return Constructor;
 }
-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;
+function _define_property(obj, key, value) {
+  if (key in obj) {
+    Object.defineProperty(obj, key, {
+      value,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  } else {
+    obj[key] = value;
+  }
+  return obj;
 }
-function _iterableToArray(iter) {
-    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+function _iterable_to_array(iter) {
+  if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null)
+    return Array.from(iter);
 }
-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 _non_iterable_spread() {
+  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 _toConsumableArray(arr) {
-    return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread();
+function _to_consumable_array(arr) {
+  return _array_without_holes(arr) || _iterable_to_array(arr) || _unsupported_iterable_to_array(arr) || _non_iterable_spread();
 }
-function _unsupportedIterableToArray(o, minLen) {
-    if (!o) return;
-    if (typeof o === "string") return _arrayLikeToArray(o, minLen);
-    var n = Object.prototype.toString.call(o).slice(8, -1);
-    if (n === "Object" && o.constructor) n = o.constructor.name;
-    if (n === "Map" || n === "Set") return Array.from(n);
-    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
+function _unsupported_iterable_to_array(o, minLen) {
+  if (!o)
+    return;
+  if (typeof o === "string")
+    return _array_like_to_array(o, minLen);
+  var n = Object.prototype.toString.call(o).slice(8, -1);
+  if (n === "Object" && o.constructor)
+    n = o.constructor.name;
+  if (n === "Map" || n === "Set")
+    return Array.from(n);
+  if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n))
+    return _array_like_to_array(o, minLen);
 }
 import minimatch from "minimatch";
-var defaultIgnores = [
-    "**/bower_components/**",
-    "**/coverage/**",
-    "**/node_modules/**",
-    "**/.*/**",
-    "**/*.d.ts",
-    "**/*.log"
+export var defaultIgnores = [
+  "**/bower_components/**",
+  "**/coverage/**",
+  "**/node_modules/**",
+  "**/.*/**",
+  "**/*.d.ts",
+  "**/*.log"
 ];
-var DependencyTree = /*#__PURE__*/ function() {
-    "use strict";
-    function DependencyTree() {
-        _classCallCheck(this, DependencyTree);
-        _defineProperty(this, "tree", void 0);
-        _defineProperty(this, "ignore", void 0);
-        this.tree = /* @__PURE__ */ new Map();
-        this.ignore = _toConsumableArray(defaultIgnores);
-    }
-    _createClass(DependencyTree, [
-        {
-            key: "getNode",
-            value: function getNode(path) {
-                return this.tree.get(path);
+export var DependencyTree = /* @__PURE__ */ function() {
+  "use strict";
+  function DependencyTree2() {
+    _class_call_check(this, DependencyTree2);
+    _define_property(this, "tree", void 0);
+    _define_property(this, "ignore", void 0);
+    this.tree = /* @__PURE__ */ new Map();
+    this.ignore = _to_consumable_array(defaultIgnores);
+  }
+  _create_class(DependencyTree2, [
+    {
+      key: "getNode",
+      value: function getNode(path) {
+        return this.tree.get(path);
+      }
+    },
+    {
+      key: "update",
+      value: (
+        /**
+        * update dependency tree
+        *
+        * @param cache
+        */
+        function update(cache) {
+          var _this = this;
+          this.tree.clear();
+          Object.keys(cache).forEach(function(path) {
+            if (!_this.shouldIgnore(path)) {
+              var module = cache[path];
+              _this.tree.set(module.filename, {
+                module,
+                parent: /* @__PURE__ */ new Set(),
+                children: /* @__PURE__ */ new Set()
+              });
             }
-        },
-        {
-            /**
-   * update dependency tree
-   *
-   * @param cache
-   */ key: "update",
-            value: function update(cache) {
-                var _this = this;
-                this.tree.clear();
-                Object.keys(cache).forEach(function(path) {
-                    if (!_this.shouldIgnore(path)) {
-                        var module = cache[path];
-                        _this.tree.set(module.filename, {
-                            module: module,
-                            parent: /* @__PURE__ */ new Set(),
-                            children: /* @__PURE__ */ new Set()
-                        });
-                    }
-                });
-                var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
-                try {
-                    var _this1 = this, _loop = function() {
-                        var treeNode = _step.value;
-                        var parent = treeNode.module.parent;
-                        var children = treeNode.module.children;
-                        if (parent && !_this1.shouldIgnore(parent.filename)) {
-                            var parentTreeNode = _this1.tree.get(parent.filename);
-                            if (parentTreeNode) {
-                                treeNode.parent.add(parentTreeNode);
-                            }
-                        }
-                        children.forEach(function(child) {
-                            if (!_this.shouldIgnore(child.filename)) {
-                                var childTreeNode = _this.tree.get(child.filename);
-                                if (childTreeNode) {
-                                    treeNode.children.add(childTreeNode);
-                                    childTreeNode.parent.add(treeNode);
-                                }
-                            }
-                        });
-                    };
-                    for(var _iterator = this.tree.values()[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true)_loop();
-                } catch (err) {
-                    _didIteratorError = true;
-                    _iteratorError = err;
-                } finally{
-                    try {
-                        if (!_iteratorNormalCompletion && _iterator.return != null) {
-                            _iterator.return();
-                        }
-                    } finally{
-                        if (_didIteratorError) {
-                            throw _iteratorError;
-                        }
-                    }
+          });
+          var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = void 0;
+          try {
+            var _this1 = this, _loop = function() {
+              var treeNode = _step.value;
+              var parent = treeNode.module.parent;
+              var children = treeNode.module.children;
+              if (parent && !_this1.shouldIgnore(parent.filename)) {
+                var parentTreeNode = _this1.tree.get(parent.filename);
+                if (parentTreeNode) {
+                  treeNode.parent.add(parentTreeNode);
                 }
+              }
+              children.forEach(function(child) {
+                if (!_this.shouldIgnore(child.filename)) {
+                  var childTreeNode = _this.tree.get(child.filename);
+                  if (childTreeNode) {
+                    treeNode.children.add(childTreeNode);
+                    childTreeNode.parent.add(treeNode);
+                  }
+                }
+              });
+            };
+            for (var _iterator = this.tree.values()[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true)
+              _loop();
+          } catch (err) {
+            _didIteratorError = true;
+            _iteratorError = err;
+          } finally {
+            try {
+              if (!_iteratorNormalCompletion && _iterator.return != null) {
+                _iterator.return();
+              }
+            } finally {
+              if (_didIteratorError) {
+                throw _iteratorError;
+              }
             }
-        },
-        {
-            key: "shouldIgnore",
-            value: function shouldIgnore(path) {
-                return !path || Boolean(this.ignore.find(function(rule) {
-                    return minimatch.match([
-                        path
-                    ], rule, {
-                        dot: true
-                    }).length > 0;
-                }));
-            }
+          }
         }
-    ]);
-    return DependencyTree;
+      )
+    },
+    {
+      key: "shouldIgnore",
+      value: function shouldIgnore(path) {
+        return !path || Boolean(this.ignore.find(function(rule) {
+          return minimatch.match([
+            path
+          ], rule, {
+            dot: true
+          }).length > 0;
+        }));
+      }
+    }
+  ]);
+  return DependencyTree2;
 }();
-export { DependencyTree, defaultIgnores };