@modern-js/server 2.6.0 → 2.6.1-alpha.0

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 _this_dependencyTree;
+                (_this_dependencyTree = this.dependencyTree) === null || _this_dependencyTree === void 0 ? void 0 : _this_dependencyTree.update(require.cache);
+            }
+        },
+        {
+            key: "cleanDepCache",
+            value: function cleanDepCache(filepath) {
+                var _this_dependencyTree;
+                var node = (_this_dependencyTree = this.dependencyTree) === null || _this_dependencyTree === void 0 ? void 0 : _this_dependencyTree.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 _this = this, cachedHash = _this.cachedHash, cachedSize = _this.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 _this = this, cachedHash = _this.cachedHash, cachedSize = _this.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 _this = this, cachedHash = _this.cachedHash, cachedSize = _this.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 };

package/dist/{esm → js/treeshaking}/server/dev-server.js

@@ -432,8 +432,7 @@ var ModernDevServer = /*#__PURE__*/ function(ModernServer) {
         },
         {
             key: "onInit",
-            value: // Complete the preparation of services
-            function onInit(runner, app) {
+            value: function onInit(runner, app) {
                 var _this = this;
                 var _this1 = this, _superprop_get_onInit = function() {
                     return _get(_getPrototypeOf(ModernDevServer.prototype), "onInit", _this);

package/dist/js/treeshaking/server/index.js

@@ -0,0 +1,92 @@
+function _assertThisInitialized(self) {
+    if (self === void 0) {
+        throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+    }
+    return self;
+}
+function _classCallCheck(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _getPrototypeOf(o) {
+    _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) {
+        return o.__proto__ || Object.getPrototypeOf(o);
+    };
+    return _getPrototypeOf(o);
+}
+function _inherits(subClass, superClass) {
+    if (typeof superClass !== "function" && superClass !== null) {
+        throw new TypeError("Super expression must either be null or a function");
+    }
+    subClass.prototype = Object.create(superClass && superClass.prototype, {
+        constructor: {
+            value: subClass,
+            writable: true,
+            configurable: true
+        }
+    });
+    if (superClass) _setPrototypeOf(subClass, superClass);
+}
+function _possibleConstructorReturn(self, call) {
+    if (call && (_typeof(call) === "object" || typeof call === "function")) {
+        return call;
+    }
+    return _assertThisInitialized(self);
+}
+function _setPrototypeOf(o, p) {
+    _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {
+        o.__proto__ = p;
+        return o;
+    };
+    return _setPrototypeOf(o, p);
+}
+var _typeof = function(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+};
+function _isNativeReflectConstruct() {
+    if (typeof Reflect === "undefined" || !Reflect.construct) return false;
+    if (Reflect.construct.sham) return false;
+    if (typeof Proxy === "function") return true;
+    try {
+        Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {}));
+        return true;
+    } catch (e) {
+        return false;
+    }
+}
+function _createSuper(Derived) {
+    var hasNativeReflectConstruct = _isNativeReflectConstruct();
+    return function _createSuperInternal() {
+        var Super = _getPrototypeOf(Derived), result;
+        if (hasNativeReflectConstruct) {
+            var NewTarget = _getPrototypeOf(this).constructor;
+            result = Reflect.construct(Super, arguments, NewTarget);
+        } else {
+            result = Super.apply(this, arguments);
+        }
+        return _possibleConstructorReturn(this, result);
+    };
+}
+import { Server } from "@modern-js/prod-server";
+import { ModernDevServer } from "./dev-server";
+var createDevServer = function(options) {
+    return new ModernDevServer(options);
+};
+var DevServer = /*#__PURE__*/ function(Server) {
+    "use strict";
+    _inherits(DevServer, Server);
+    var _super = _createSuper(DevServer);
+    function DevServer(options) {
+        _classCallCheck(this, DevServer);
+        var _this;
+        _this = _super.call(this, options);
+        if (options.dev) {
+            _this.serverImpl = createDevServer;
+        }
+        return _this;
+    }
+    return DevServer;
+}(Server);
+export { DevServer };

package/dist/js/treeshaking/types.js

@@ -0,0 +1 @@
+"use strict";

package/dist/types/server/{dev-server.d.ts → devServer.d.ts}

@@ -1,12 +1,14 @@
 /// <reference types="node" />
 /// <reference types="node" />
 import { IncomingMessage, Server, ServerResponse } from 'http';
-import { ServerHookRunner, ModernServer, BuildOptions } from '@modern-js/prod-server';
+import { NextFunction, ServerHookRunner, ModernServer, BuildOptions } from '@modern-js/prod-server';
+import type { ModernServerContext } from '@modern-js/types';
 import { WatchEvent } from '../dev-tools/watcher';
 import type { ModernDevServerOptions } from '../types';
 export declare class ModernDevServer extends ModernServer {
   private mockHandler;
   private readonly dev;
+  private readonly appContext;
   private readonly devMiddleware;
   private watcher?;
   constructor(options: ModernDevServerOptions);
@@ -26,6 +28,7 @@ export declare class ModernDevServer extends ModernServer {
     event: WatchEvent;
   }): void;
   protected createContext(req: IncomingMessage, res: ServerResponse): import("@modern-js/prod-server/src/libs/context").ModernServerContext;
+  protected setupStaticMiddleware(_: string): (context: ModernServerContext, next: NextFunction) => Promise<void>;
   private setupBeforeDevMiddleware;
   private setupAfterDevMiddleware;
   private cleanSSRCache;

package/package.json

@@ -11,7 +11,7 @@
     "modern",
     "modern.js"
   ],
-  "version": "2.6.0",
+  "version": "2.6.1-alpha.0",
   "jsnext:source": "./src/index.ts",
   "types": "./dist/types/index.d.ts",
   "main": "./dist/cjs/index.js",
@@ -29,16 +29,19 @@
   "dependencies": {
     "@babel/core": "^7.18.0",
     "@babel/register": "^7.17.7",
+    "@modern-js/prod-server": "2.6.0",
+    "@modern-js/server-utils": "2.6.0",
+    "@modern-js/types": "2.6.0",
+    "@modern-js/utils": "2.6.0",
     "connect-history-api-fallback": "^2.0.0",
     "minimatch": "^3.0.4",
     "path-to-regexp": "^6.2.0",
-    "ws": "^8.2.0",
-    "@modern-js/prod-server": "2.6.0",
-    "@modern-js/types": "2.6.0",
-    "@modern-js/server-utils": "2.6.0",
-    "@modern-js/utils": "2.6.0"
+    "ws": "^8.2.0"
   },
   "devDependencies": {
+    "@modern-js/server-core": "2.6.0",
+    "@scripts/build": "2.6.0",
+    "@scripts/jest-config": "2.6.0",
     "@types/connect-history-api-fallback": "^1.3.5",
     "@types/jest": "^27",
     "@types/minimatch": "^3.0.5",
@@ -50,10 +53,7 @@
     "tsconfig-paths": "4.1.1",
     "typescript": "^4",
     "webpack": "^5.75.0",
-    "websocket": "^1",
-    "@modern-js/server-core": "2.6.0",
-    "@scripts/jest-config": "2.6.0",
-    "@scripts/build": "2.6.0"
+    "websocket": "^1"
   },
   "peerDependencies": {
     "devcert": "^1.0.0",