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

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/dev-tools/mock/getMockData.d.ts

@@ -11,6 +11,8 @@ export declare type MockApi = {
 };
 declare const createFunctionDataHandler: (method: string, handler: (req: IncomingMessage, res: ServerResponse, next: NextFunction) => void) => (context: ModernServerContext, next: NextFunction) => Promise<void>;
 declare const createStaticDataHandler: (method: string, handler: Record<string, any>) => (context: ModernServerContext) => void;
+
 declare const _default: (filepath: string) => MockApi[];
+
 export default _default;
 export declare const getMatched: (context: ModernServerContext, mockApiList: MockApi[]) => MockApi | undefined;

package/dist/types/dev-tools/watcher/dependency-tree.d.ts

@@ -14,6 +14,7 @@ export interface TreeNode {
  * `module.parent` is the module that first required. so we have to implement
  *  a new tree which revisit the cache tree to find all parent node
  */
+
 export declare class DependencyTree {
   private readonly tree;
   private readonly ignore;
@@ -24,6 +25,7 @@ export declare class DependencyTree {
    *
    * @param cache
    */
+
   update(cache: any): void;
   private shouldIgnore;
 }

package/dist/types/dev-tools/watcher/index.d.ts

@@ -5,7 +5,7 @@ export declare const defaultWatchOptions: {
   ignored: RegExp;
 };
 export declare const getWatchedFiles: (watcher: FSWatcher) => string[];
-export declare const mergeWatchOptions: (options?: any) => any;
+export declare const mergeWatchOptions: (options?: WatchOptions) => WatchOptions;
 export default class Watcher {
   private dependencyTree;
   private watcher;

package/dist/types/index.d.ts

@@ -2,5 +2,7 @@ import { DevServer as Server } from './server';
 import type { ModernDevServerOptions } from './types';
 export { Server };
 export type { ModernDevServerOptions };
+
 declare const _default: (options: ModernDevServerOptions) => Promise<Server>;
+
 export default _default;

package/package.json

@@ -11,7 +11,7 @@
     "modern",
     "modern.js"
   ],
-  "version": "2.0.0-beta.3",
+  "version": "2.0.0-beta.4",
   "jsnext:source": "./src/index.ts",
   "types": "./dist/types/index.d.ts",
   "main": "./dist/js/node/index.js",
@@ -35,10 +35,10 @@
     "minimatch": "^3.0.4",
     "path-to-regexp": "^6.2.0",
     "ws": "^8.2.0",
-    "@modern-js/prod-server": "2.0.0-beta.3",
-    "@modern-js/server-utils": "2.0.0-beta.3",
-    "@modern-js/types": "2.0.0-beta.3",
-    "@modern-js/utils": "2.0.0-beta.3"
+    "@modern-js/prod-server": "2.0.0-beta.4",
+    "@modern-js/server-utils": "2.0.0-beta.4",
+    "@modern-js/types": "2.0.0-beta.4",
+    "@modern-js/utils": "2.0.0-beta.4"
   },
   "devDependencies": {
     "@types/connect-history-api-fallback": "^1.3.5",
@@ -53,27 +53,30 @@
     "typescript": "^4",
     "webpack": "^5.75.0",
     "websocket": "^1",
-    "@modern-js/server-core": "2.0.0-beta.3",
-    "@scripts/build": "2.0.0-beta.3",
-    "@scripts/jest-config": "2.0.0-beta.3"
+    "@modern-js/server-core": "2.0.0-beta.4",
+    "@scripts/build": "2.0.0-beta.4",
+    "@scripts/jest-config": "2.0.0-beta.4"
   },
   "peerDependencies": {
     "ts-node": "^10.1.0",
     "tsconfig-paths": ">= 3.0.0 || >= 4.0.0"
   },
-  "sideEffects": false,
-  "modernConfig": {
-    "output": {
-      "packageMode": "node-js"
+  "peerDependenciesMeta": {
+    "ts-node": {
+      "optional": true
+    },
+    "tsconfig-paths": {
+      "optional": true
     }
   },
+  "sideEffects": false,
   "publishConfig": {
     "registry": "https://registry.npmjs.org/",
     "access": "public"
   },
   "scripts": {
     "new": "modern-lib new",
-    "build": "modern-lib build",
+    "build": "modern-lib build && node ./temp-fix-hmr.js",
     "dev": "modern-lib build --watch",
     "test": "jest"
   }

package/temp-fix-hmr.js

@@ -0,0 +1,483 @@
+// FIXME: 临时修复 HMR 代码
+// TODO: 修复 HMR 问题后移除
+// eslint-disable-next-line eslint-comments/disable-enable-pair
+/* eslint-disable max-lines */
+
+const path = require('path');
+const { fs } = require('@modern-js/utils');
+
+fs.outputFileSync(
+  path.join(
+    __dirname,
+    'dist/js/node/dev-tools/dev-middleware/hmr-client/index.js',
+  ),
+  `var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var import_strip_ansi = __toESM(require("@modern-js/utils/strip-ansi"));
+var import_format = require("@modern-js/utils/format");
+var import_createSocketUrl = require("./createSocketUrl");
+const hadRuntimeError = false;
+const socketUrl = (0, import_createSocketUrl.createSocketUrl)(__resourceQuery);
+const connection = new WebSocket(socketUrl);
+connection.onclose = function() {
+  if (typeof console !== "undefined" && typeof console.info === "function") {
+    console.info(
+      "The development server has disconnected. Refresh the page if necessary."
+    );
+  }
+};
+let isFirstCompilation = true;
+let mostRecentCompilationHash = null;
+let hasCompileErrors = false;
+function clearOutdatedErrors() {
+  if (typeof console !== "undefined" && typeof console.clear === "function") {
+    if (hasCompileErrors) {
+      console.clear();
+    }
+  }
+}
+function handleSuccess() {
+  clearOutdatedErrors();
+  const isHotUpdate = !isFirstCompilation;
+  isFirstCompilation = false;
+  hasCompileErrors = false;
+  if (isHotUpdate) {
+    tryApplyUpdates();
+  }
+}
+function handleWarnings(warnings) {
+  clearOutdatedErrors();
+  const isHotUpdate = !isFirstCompilation;
+  isFirstCompilation = false;
+  hasCompileErrors = false;
+  function printWarnings() {
+    const formatted = (0, import_format.formatWebpackMessages)({
+      warnings,
+      errors: []
+    });
+    if (typeof console !== "undefined" && typeof console.warn === "function") {
+      for (let i = 0; i < formatted.warnings.length; i++) {
+        if (i === 5) {
+          console.warn(
+            "There were more warnings in other files. You can find a complete log in the terminal."
+          );
+          break;
+        }
+        console.warn((0, import_strip_ansi.default)(formatted.warnings[i]));
+      }
+    }
+  }
+  printWarnings();
+  if (isHotUpdate) {
+    tryApplyUpdates();
+  }
+}
+function handleErrors(errors) {
+  clearOutdatedErrors();
+  isFirstCompilation = false;
+  hasCompileErrors = true;
+  const formatted = (0, import_format.formatWebpackMessages)({
+    errors,
+    warnings: []
+  });
+  if (typeof console !== "undefined" && typeof console.error === "function") {
+    for (const error of formatted.errors) {
+      console.error((0, import_strip_ansi.default)(error));
+    }
+  }
+}
+function handleAvailableHash(hash) {
+  mostRecentCompilationHash = hash;
+}
+connection.onmessage = function(e) {
+  const message = JSON.parse(e.data);
+  switch (message.type) {
+    case "hash":
+      handleAvailableHash(message.data);
+      break;
+    case "still-ok":
+    case "ok":
+      handleSuccess();
+      break;
+    case "content-changed":
+      window.location.reload();
+      break;
+    case "warnings":
+      handleWarnings(message.data);
+      break;
+    case "errors":
+      handleErrors(message.data);
+      break;
+    default:
+  }
+};
+function isUpdateAvailable() {
+  return mostRecentCompilationHash !== __webpack_hash__;
+}
+function canApplyUpdates() {
+  return module.hot.status() === "idle";
+}
+function tryApplyUpdates() {
+  if (!module.hot) {
+    window.location.reload();
+    return;
+  }
+  if (!isUpdateAvailable() || !canApplyUpdates()) {
+    return;
+  }
+  function handleApplyUpdates(err, updatedModules) {
+    const wantsForcedReload = err || !updatedModules || hadRuntimeError;
+    if (wantsForcedReload) {
+      window.location.reload();
+      return;
+    }
+    if (isUpdateAvailable()) {
+      tryApplyUpdates();
+    }
+  }
+  const result = module.hot.check(true, handleApplyUpdates);
+  if (result == null ? void 0 : result.then) {
+    result.then(
+      (updatedModules) => {
+        handleApplyUpdates(null, updatedModules);
+      },
+      (err) => {
+        handleApplyUpdates(err, null);
+      }
+    );
+  }
+}
+`,
+);
+
+fs.outputFileSync(
+  path.join(
+    __dirname,
+    'dist/js/modern/dev-tools/dev-middleware/hmr-client/index.js',
+  ),
+  `var __getOwnPropNames = Object.getOwnPropertyNames;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+import stripAnsi from "@modern-js/utils/strip-ansi";
+import { formatWebpackMessages } from "@modern-js/utils/format";
+import { createSocketUrl } from "./createSocketUrl";
+var require_hmr_client = __commonJS({
+  "src/dev-tools/dev-middleware/hmr-client/index.ts"(exports, module) {
+    const hadRuntimeError = false;
+    const socketUrl = createSocketUrl(__resourceQuery);
+    const connection = new WebSocket(socketUrl);
+    connection.onclose = function() {
+      if (typeof console !== "undefined" && typeof console.info === "function") {
+        console.info(
+          "The development server has disconnected. Refresh the page if necessary."
+        );
+      }
+    };
+    let isFirstCompilation = true;
+    let mostRecentCompilationHash = null;
+    let hasCompileErrors = false;
+    function clearOutdatedErrors() {
+      if (typeof console !== "undefined" && typeof console.clear === "function") {
+        if (hasCompileErrors) {
+          console.clear();
+        }
+      }
+    }
+    function handleSuccess() {
+      clearOutdatedErrors();
+      const isHotUpdate = !isFirstCompilation;
+      isFirstCompilation = false;
+      hasCompileErrors = false;
+      if (isHotUpdate) {
+        tryApplyUpdates();
+      }
+    }
+    function handleWarnings(warnings) {
+      clearOutdatedErrors();
+      const isHotUpdate = !isFirstCompilation;
+      isFirstCompilation = false;
+      hasCompileErrors = false;
+      function printWarnings() {
+        const formatted = formatWebpackMessages({
+          warnings,
+          errors: []
+        });
+        if (typeof console !== "undefined" && typeof console.warn === "function") {
+          for (let i = 0; i < formatted.warnings.length; i++) {
+            if (i === 5) {
+              console.warn(
+                "There were more warnings in other files. You can find a complete log in the terminal."
+              );
+              break;
+            }
+            console.warn(stripAnsi(formatted.warnings[i]));
+          }
+        }
+      }
+      printWarnings();
+      if (isHotUpdate) {
+        tryApplyUpdates();
+      }
+    }
+    function handleErrors(errors) {
+      clearOutdatedErrors();
+      isFirstCompilation = false;
+      hasCompileErrors = true;
+      const formatted = formatWebpackMessages({
+        errors,
+        warnings: []
+      });
+      if (typeof console !== "undefined" && typeof console.error === "function") {
+        for (const error of formatted.errors) {
+          console.error(stripAnsi(error));
+        }
+      }
+    }
+    function handleAvailableHash(hash) {
+      mostRecentCompilationHash = hash;
+    }
+    connection.onmessage = function(e) {
+      const message = JSON.parse(e.data);
+      switch (message.type) {
+        case "hash":
+          handleAvailableHash(message.data);
+          break;
+        case "still-ok":
+        case "ok":
+          handleSuccess();
+          break;
+        case "content-changed":
+          window.location.reload();
+          break;
+        case "warnings":
+          handleWarnings(message.data);
+          break;
+        case "errors":
+          handleErrors(message.data);
+          break;
+        default:
+      }
+    };
+    function isUpdateAvailable() {
+      return mostRecentCompilationHash !== __webpack_hash__;
+    }
+    function canApplyUpdates() {
+      return module.hot.status() === "idle";
+    }
+    function tryApplyUpdates() {
+      if (!module.hot) {
+        window.location.reload();
+        return;
+      }
+      if (!isUpdateAvailable() || !canApplyUpdates()) {
+        return;
+      }
+      function handleApplyUpdates(err, updatedModules) {
+        const wantsForcedReload = err || !updatedModules || hadRuntimeError;
+        if (wantsForcedReload) {
+          window.location.reload();
+          return;
+        }
+        if (isUpdateAvailable()) {
+          tryApplyUpdates();
+        }
+      }
+      const result = module.hot.check(true, handleApplyUpdates);
+      if (result == null ? void 0 : result.then) {
+        result.then(
+          (updatedModules) => {
+            handleApplyUpdates(null, updatedModules);
+          },
+          (err) => {
+            handleApplyUpdates(err, null);
+          }
+        );
+      }
+    }
+  }
+});
+export default require_hmr_client();
+`,
+);
+
+fs.outputFileSync(
+  path.join(
+    __dirname,
+    'dist/js/treeshaking/dev-tools/dev-middleware/hmr-client/index.js',
+  ),
+  `var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __commonJS = function(cb, mod) {
+      return function __require() {
+          return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = {
+              exports: {}
+          }).exports, mod), mod.exports;
+      };
+  };
+  import stripAnsi from "@modern-js/utils/strip-ansi";
+  import { formatWebpackMessages } from "@modern-js/utils/format";
+  import { createSocketUrl } from "./createSocketUrl";
+  var require_hmr_client = __commonJS({
+      "src/dev-tools/dev-middleware/hmr-client/index.ts": function(exports, module) {
+          var clearOutdatedErrors = function clearOutdatedErrors() {
+              if (typeof console !== "undefined" && typeof console.clear === "function") {
+                  if (hasCompileErrors) {
+                      console.clear();
+                  }
+              }
+          };
+          var handleSuccess = function handleSuccess() {
+              clearOutdatedErrors();
+              var isHotUpdate = !isFirstCompilation;
+              isFirstCompilation = false;
+              hasCompileErrors = false;
+              if (isHotUpdate) {
+                  tryApplyUpdates();
+              }
+          };
+          var handleWarnings = function handleWarnings(warnings) {
+              clearOutdatedErrors();
+              var isHotUpdate = !isFirstCompilation;
+              isFirstCompilation = false;
+              hasCompileErrors = false;
+              function printWarnings() {
+                  var formatted = formatWebpackMessages({
+                      warnings: warnings,
+                      errors: []
+                  });
+                  if (typeof console !== "undefined" && typeof console.warn === "function") {
+                      for(var i = 0; i < formatted.warnings.length; i++){
+                          if (i === 5) {
+                              console.warn("There were more warnings in other files. You can find a complete log in the terminal.");
+                              break;
+                          }
+                          console.warn(stripAnsi(formatted.warnings[i]));
+                      }
+                  }
+              }
+              printWarnings();
+              if (isHotUpdate) {
+                  tryApplyUpdates();
+              }
+          };
+          var handleErrors = function handleErrors(errors) {
+              clearOutdatedErrors();
+              isFirstCompilation = false;
+              hasCompileErrors = true;
+              var formatted = formatWebpackMessages({
+                  errors: errors,
+                  warnings: []
+              });
+              if (typeof console !== "undefined" && typeof console.error === "function") {
+                  var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                  try {
+                      for(var _iterator = formatted.errors[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                          var error = _step.value;
+                          console.error(stripAnsi(error));
+                      }
+                  } catch (err) {
+                      _didIteratorError = true;
+                      _iteratorError = err;
+                  } finally{
+                      try {
+                          if (!_iteratorNormalCompletion && _iterator.return != null) {
+                              _iterator.return();
+                          }
+                      } finally{
+                          if (_didIteratorError) {
+                              throw _iteratorError;
+                          }
+                      }
+                  }
+              }
+          };
+          var handleAvailableHash = function handleAvailableHash(hash) {
+              mostRecentCompilationHash = hash;
+          };
+          var isUpdateAvailable = function isUpdateAvailable() {
+              return mostRecentCompilationHash !== __webpack_hash__;
+          };
+          var canApplyUpdates = function canApplyUpdates() {
+              return module.hot.status() === "idle";
+          };
+          var hadRuntimeError = false;
+          var socketUrl = createSocketUrl(__resourceQuery);
+          var connection = new WebSocket(socketUrl);
+          connection.onclose = function() {
+              if (typeof console !== "undefined" && typeof console.info === "function") {
+                  console.info("The development server has disconnected. Refresh the page if necessary.");
+              }
+          };
+          var isFirstCompilation = true;
+          var mostRecentCompilationHash = null;
+          var hasCompileErrors = false;
+          connection.onmessage = function(e) {
+              var message = JSON.parse(e.data);
+              switch(message.type){
+                  case "hash":
+                      handleAvailableHash(message.data);
+                      break;
+                  case "still-ok":
+                  case "ok":
+                      handleSuccess();
+                      break;
+                  case "content-changed":
+                      window.location.reload();
+                      break;
+                  case "warnings":
+                      handleWarnings(message.data);
+                      break;
+                  case "errors":
+                      handleErrors(message.data);
+                      break;
+                  default:
+              }
+          };
+          function tryApplyUpdates() {
+              if (!module.hot) {
+                  window.location.reload();
+                  return;
+              }
+              if (!isUpdateAvailable() || !canApplyUpdates()) {
+                  return;
+              }
+              function handleApplyUpdates(err, updatedModules) {
+                  var wantsForcedReload = err || !updatedModules || hadRuntimeError;
+                  if (wantsForcedReload) {
+                      window.location.reload();
+                      return;
+                  }
+                  if (isUpdateAvailable()) {
+                      tryApplyUpdates();
+                  }
+              }
+              var result = module.hot.check(true, handleApplyUpdates);
+              if (result === null || result === void 0 ? void 0 : result.then) {
+                  result.then(function(updatedModules) {
+                      handleApplyUpdates(null, updatedModules);
+                  }, function(err) {
+                      handleApplyUpdates(err, null);
+                  });
+              }
+          }
+      }
+  });
+  export default require_hmr_client();
+`,
+);