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

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

@@ -0,0 +1,153 @@
+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 _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]);
+        });
+    }
+    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);
+    }
+    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;
+}
+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 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 ref;
+        debug("use ts-node");
+        var distPath = ((ref = config.output.distPath) === null || ref === void 0 ? void 0 : ref.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 _paths = aliasConfig.paths, paths = _paths === void 0 ? {} : _paths, _absoluteBaseUrl = aliasConfig.absoluteBaseUrl, absoluteBaseUrl = _absoluteBaseUrl === void 0 ? "./" : _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,
+            files: true,
+            transpileOnly: true,
+            ignore: [
+                "(?:^|/)node_modules/",
+                "(?:^|/)".concat(distPath, "/")
+            ]
+        });
+    } else {
+        var ref1, ref2;
+        debug("use @babel/register");
+        var babelConfig = resolveBabelConfig(projectRoot, _objectSpreadProps(_objectSpread({}, config.source), {
+            babelConfig: (ref1 = config.tools) === null || ref1 === void 0 ? void 0 : ref1.babel,
+            server: {
+                compiler: (ref2 = config.server) === null || ref2 === void 0 ? void 0 : ref2.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 { enableRegister };

package/dist/js/treeshaking/dev-tools/watcher/dependency-tree.js

@@ -0,0 +1,150 @@
+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 _arrayWithoutHoles(arr) {
+    if (Array.isArray(arr)) return _arrayLikeToArray(arr);
+}
+function _classCallCheck(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);
+    }
+}
+function _createClass(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 _iterableToArray(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 _toConsumableArray(arr) {
+    return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread();
+}
+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);
+}
+import minimatch from "minimatch";
+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);
+            }
+        },
+        {
+            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;
+                        }
+                    }
+                }
+            }
+        },
+        {
+            key: "shouldIgnore",
+            value: function shouldIgnore(path) {
+                return !path || Boolean(this.ignore.find(function(rule) {
+                    return minimatch.match([
+                        path
+                    ], rule).length > 0;
+                }));
+            }
+        }
+    ]);
+    return DependencyTree;
+}();
+export { DependencyTree, defaultIgnores };

package/dist/js/treeshaking/dev-tools/watcher/index.js

@@ -0,0 +1,200 @@
+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 _arrayWithoutHoles(arr) {
+    if (Array.isArray(arr)) return _arrayLikeToArray(arr);
+}
+function _classCallCheck(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);
+    }
+}
+function _createClass(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 _iterableToArray(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 _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]);
+        });
+    }
+    return target;
+}
+function _toConsumableArray(arr) {
+    return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread();
+}
+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);
+}
+import path from "path";
+import { fs, chokidar } from "@modern-js/utils";
+import { DependencyTree } from "./dependency-tree";
+import { StatsCache } from "./stats-cache";
+var defaultWatchOptions = {
+    ignoreInitial: true,
+    ignored: /api\/typings\/.*/
+};
+var getWatchedFiles = function(watcher) {
+    var watched = watcher.getWatched();
+    var files = [];
+    Object.keys(watched).forEach(function(dir) {
+        watched[dir].forEach(function(fileName) {
+            files.push(path.join(dir, fileName));
+        });
+    });
+    return files;
+};
+var mergeWatchOptions = function(options) {
+    var watchOptions = _objectSpread({}, options);
+    if (watchOptions) {
+        var ignored = watchOptions.ignored;
+        var finalIgnored = ignored ? [
+            defaultWatchOptions.ignored
+        ].concat(_toConsumableArray(Array.isArray(ignored) ? ignored : [
+            ignored
+        ])) : ignored;
+        if (finalIgnored) {
+            watchOptions.ignored = finalIgnored;
+        }
+    }
+    var finalWatchOptions = _objectSpread({}, defaultWatchOptions, watchOptions);
+    return finalWatchOptions;
+};
+var Watcher = /*#__PURE__*/ function() {
+    "use strict";
+    function Watcher() {
+        _classCallCheck(this, Watcher);
+        _defineProperty(this, "dependencyTree", null);
+        _defineProperty(this, "watcher", void 0);
+    }
+    _createClass(Watcher, [
+        {
+            key: "listen",
+            value: function listen(files, options, callback) {
+                var watched = files.filter(Boolean);
+                var filenames = watched.map(function(filename) {
+                    return filename.replace(/\\/g, "/");
+                });
+                var cache = new StatsCache();
+                var watcher = chokidar.watch(filenames, options);
+                watcher.on("ready", function() {
+                    cache.add(getWatchedFiles(watcher));
+                });
+                watcher.on("change", function(changed) {
+                    if (!fs.existsSync(changed) || cache.isDiff(changed)) {
+                        cache.refresh(changed);
+                        callback(changed, "change");
+                    }
+                });
+                watcher.on("add", function(changed) {
+                    if (!cache.has(changed)) {
+                        cache.add([
+                            changed
+                        ]);
+                        callback(changed, "add");
+                    }
+                });
+                watcher.on("unlink", function(changed) {
+                    cache.del(changed);
+                    callback(changed, "unlink");
+                });
+                this.watcher = watcher;
+            }
+        },
+        {
+            key: "createDepTree",
+            value: function createDepTree() {
+                this.dependencyTree = new DependencyTree();
+            }
+        },
+        {
+            key: "updateDepTree",
+            value: function updateDepTree() {
+                var ref;
+                (ref = this.dependencyTree) === null || ref === void 0 ? void 0 : ref.update(require.cache);
+            }
+        },
+        {
+            key: "cleanDepCache",
+            value: function cleanDepCache(filepath) {
+                var ref;
+                var node = (ref = this.dependencyTree) === null || ref === void 0 ? void 0 : ref.getNode(filepath);
+                if (node && require.cache[filepath]) {
+                    delete require.cache[filepath];
+                    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                    try {
+                        for(var _iterator = node.parent.values()[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                            var parentNode = _step.value;
+                            this.cleanDepCache(parentNode.module.filename);
+                        }
+                    } catch (err) {
+                        _didIteratorError = true;
+                        _iteratorError = err;
+                    } finally{
+                        try {
+                            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                                _iterator.return();
+                            }
+                        } finally{
+                            if (_didIteratorError) {
+                                throw _iteratorError;
+                            }
+                        }
+                    }
+                }
+            }
+        },
+        {
+            key: "close",
+            value: function close() {
+                return this.watcher.close();
+            }
+        }
+    ]);
+    return Watcher;
+}();
+export { Watcher as default, defaultWatchOptions, getWatchedFiles, mergeWatchOptions };

package/dist/js/treeshaking/dev-tools/watcher/stats-cache.js

@@ -0,0 +1,128 @@
+function _classCallCheck(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);
+    }
+}
+function _createClass(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;
+}
+import fs from "fs";
+import crypto from "crypto";
+var StatsCache = /*#__PURE__*/ function() {
+    "use strict";
+    function StatsCache() {
+        _classCallCheck(this, StatsCache);
+        _defineProperty(this, "cachedHash", {});
+        _defineProperty(this, "cachedSize", {});
+    }
+    _createClass(StatsCache, [
+        {
+            key: "add",
+            value: function add(files) {
+                var ref = this, cachedHash = ref.cachedHash, cachedSize = ref.cachedSize;
+                var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                try {
+                    for(var _iterator = files[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                        var filename = _step.value;
+                        if (fs.existsSync(filename)) {
+                            var stats = fs.statSync(filename);
+                            if (stats.isFile() && !cachedHash[filename]) {
+                                cachedHash[filename] = this.hash(stats, filename);
+                                cachedSize[filename] = stats.size;
+                            }
+                        }
+                    }
+                } catch (err) {
+                    _didIteratorError = true;
+                    _iteratorError = err;
+                } finally{
+                    try {
+                        if (!_iteratorNormalCompletion && _iterator.return != null) {
+                            _iterator.return();
+                        }
+                    } finally{
+                        if (_didIteratorError) {
+                            throw _iteratorError;
+                        }
+                    }
+                }
+            }
+        },
+        {
+            key: "refresh",
+            value: function refresh(filename) {
+                var ref = this, cachedHash = ref.cachedHash, cachedSize = ref.cachedSize;
+                if (fs.existsSync(filename)) {
+                    var stats = fs.statSync(filename);
+                    if (stats.isFile()) {
+                        cachedHash[filename] = this.hash(stats, filename);
+                        cachedSize[filename] = stats.size;
+                    }
+                }
+            }
+        },
+        {
+            key: "del",
+            value: function del(filename) {
+                if (this.cachedHash[filename]) {
+                    delete this.cachedHash[filename];
+                    delete this.cachedSize[filename];
+                }
+            }
+        },
+        {
+            key: "isDiff",
+            value: function isDiff(filename) {
+                var ref = this, cachedHash = ref.cachedHash, cachedSize = ref.cachedSize;
+                var stats = fs.statSync(filename);
+                var hash = cachedHash[filename];
+                var size = cachedSize[filename];
+                if (stats.size !== size) {
+                    return true;
+                }
+                if (this.hash(stats, filename) !== hash) {
+                    return true;
+                }
+                return false;
+            }
+        },
+        {
+            key: "has",
+            value: function has(filename) {
+                return Boolean(this.cachedHash[filename]);
+            }
+        },
+        {
+            key: "hash",
+            value: function hash(stats, filename) {
+                return crypto.createHash("md5").update(fs.readFileSync(filename)).digest("hex");
+            }
+        }
+    ]);
+    return StatsCache;
+}();
+export { StatsCache };

package/dist/js/treeshaking/index.js

@@ -0,0 +1,9 @@
+import { DevServer as Server } from "./server";
+var src_default = function(options) {
+    if (options == null) {
+        throw new Error("can not start server without options");
+    }
+    var server = new Server(options);
+    return server.init();
+};
+export { Server, src_default as default };