@modern-js/server 2.0.0-beta.2 → 2.0.0-beta.4

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 mserver without options");
+    }
+    var server = new Server(options);
+    return server.init();
+};
+export { Server, src_default as default };