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

package/dist/js/modern/dev-tools/dev-middleware/index.js

@@ -1,59 +1,71 @@
-function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
-function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
-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 { EventEmitter } from 'events';
-import webpackDevMiddleware from '@modern-js/utils/webpack-dev-middleware';
+var __defProp = Object.defineProperty;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+import { EventEmitter } from "events";
+import webpackDevMiddleware from "@modern-js/utils/webpack-dev-middleware";
 import DevServerPlugin from "./dev-server-plugin";
 import SocketServer from "./socket-server";
 const noop = () => {
-  // noop
 };
-export default class DevMiddleware extends EventEmitter {
-  constructor({
-    compiler,
-    dev,
-    devMiddleware
-  }) {
+class DevMiddleware extends EventEmitter {
+  constructor({ compiler, dev, devMiddleware }) {
     super();
-    _defineProperty(this, "middleware", void 0);
-    _defineProperty(this, "compiler", void 0);
-    _defineProperty(this, "devOptions", void 0);
-    _defineProperty(this, "socketServer", void 0);
     this.compiler = compiler;
     this.devOptions = dev;
-
-    // init socket server
     this.socketServer = new SocketServer(dev);
-
-    // Todo: should remove after abstract dev middleware
     if (this.compiler) {
-      // setup compiler in server, also add dev-middleware to handler static file in memory
-      // set up plugin to each compiler
       this.setupDevServerPlugin();
-      // register hooks for each compilation, update socket stats if recompiled
       this.setupHooks();
-      // start dev middleware
       this.middleware = this.setupDevMiddleware(devMiddleware);
     }
   }
   init(app) {
-    app.on('listening', () => {
+    app.on("listening", () => {
       this.socketServer.prepare(app);
     });
-    app.on('close', async () => {
-      var _this$middleware;
-      (_this$middleware = this.middleware) === null || _this$middleware === void 0 ? void 0 : _this$middleware.close(noop);
+    app.on("close", () => __async(this, null, function* () {
+      var _a;
+      (_a = this.middleware) == null ? void 0 : _a.close(noop);
       this.socketServer.close();
-    });
+    }));
   }
   setupDevServerPlugin() {
-    const {
-      devOptions
-    } = this;
-
-    // apply dev server to client compiler, add hmr client to entry.
+    const { devOptions } = this;
     if (this.compiler.compilers) {
-      this.compiler.compilers.forEach(target => {
+      this.compiler.compilers.forEach((target) => {
         if (this.isClientCompiler(target)) {
           new DevServerPlugin(devOptions).apply(target);
         }
@@ -67,22 +79,18 @@ export default class DevMiddleware extends EventEmitter {
   }
   setupHooks() {
     const invalidPlugin = () => {
-      this.socketServer.sockWrite('invalid');
+      this.socketServer.sockWrite("invalid");
     };
-    const addHooks = compiler => {
-      if (compiler.name === 'server') {
+    const addHooks = (compiler) => {
+      if (compiler.name === "server") {
         return;
       }
-      const {
-        compile,
-        invalid,
-        done
-      } = compiler.hooks;
-      compile.tap('modern-dev-server', invalidPlugin);
-      invalid.tap('modern-dev-server', invalidPlugin);
-      done.tap('modern-dev-server', stats => {
+      const { compile, invalid, done } = compiler.hooks;
+      compile.tap("modern-dev-server", invalidPlugin);
+      invalid.tap("modern-dev-server", invalidPlugin);
+      done.tap("modern-dev-server", (stats) => {
         this.socketServer.updateStats(stats);
-        this.emit('change', stats);
+        this.emit("change", stats);
       });
     };
     if (this.compiler.compilers) {
@@ -92,27 +100,24 @@ export default class DevMiddleware extends EventEmitter {
     }
   }
   setupDevMiddleware(devMiddleware = webpackDevMiddleware) {
-    const {
-      devOptions
-    } = this;
-    const middleware = devMiddleware(this.compiler, _objectSpread({
+    const { devOptions } = this;
+    const middleware = devMiddleware(this.compiler, __spreadValues({
       headers: devOptions.headers,
       stats: false
     }, devOptions.devMiddleware));
     return middleware;
   }
   isClientCompiler(compiler) {
-    const {
-      target
-    } = compiler.options;
-
-    // if target not contains `node`, it's a client compiler
+    const { target } = compiler.options;
     if (target) {
       if (Array.isArray(target)) {
-        return !target.includes('node');
+        return !target.includes("node");
       }
-      return target !== 'node';
+      return target !== "node";
     }
-    return compiler.name === 'client';
+    return compiler.name === "client";
   }
-}
+}
+export {
+  DevMiddleware as default
+};

package/dist/js/modern/dev-tools/dev-middleware/socket-server.js

@@ -1,53 +1,42 @@
-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 ws from 'ws';
-import { logger } from '@modern-js/utils';
-export default class SocketServer {
+import ws from "ws";
+import { logger } from "@modern-js/utils";
+class SocketServer {
   constructor(options) {
-    _defineProperty(this, "wsServer", void 0);
-    _defineProperty(this, "sockets", []);
-    _defineProperty(this, "options", void 0);
-    _defineProperty(this, "app", void 0);
-    _defineProperty(this, "stats", void 0);
-    _defineProperty(this, "timer", null);
+    this.sockets = [];
+    this.timer = null;
     this.options = options;
   }
-
-  // create socket, install socket handler, bind socket event
   prepare(app) {
-    var _this$options$client;
+    var _a;
     this.app = app;
     this.wsServer = new ws.Server({
       noServer: true,
-      path: (_this$options$client = this.options.client) === null || _this$options$client === void 0 ? void 0 : _this$options$client.path
+      path: (_a = this.options.client) == null ? void 0 : _a.path
     });
-
-    // listen upgrade event to handle socket
-    this.app.on('upgrade', (req, sock, head) => {
+    this.app.on("upgrade", (req, sock, head) => {
       if (!this.wsServer.shouldHandle(req)) {
         return;
       }
-      this.wsServer.handleUpgrade(req, sock, head, connection => {
-        this.wsServer.emit('connection', connection, req);
+      this.wsServer.handleUpgrade(req, sock, head, (connection) => {
+        this.wsServer.emit("connection", connection, req);
       });
     });
-    this.wsServer.on('error', err => {
-      // only dev server, use default logger
+    this.wsServer.on("error", (err) => {
       logger.error(err);
     });
     this.timer = setInterval(() => {
-      this.wsServer.clients.forEach(socket => {
+      this.wsServer.clients.forEach((socket) => {
         const extWs = socket;
         if (!extWs.isAlive) {
           extWs.terminate();
         } else {
           extWs.isAlive = false;
           extWs.ping(() => {
-            // empty
           });
         }
       });
-    }, 30000);
-    this.wsServer.on('connection', socket => {
+    }, 3e4);
+    this.wsServer.on("connection", (socket) => {
       this.onConnect(socket);
     });
   }
@@ -55,24 +44,16 @@ export default class SocketServer {
     this.stats = stats;
     this.sendStats();
   }
-
-  // write message to each socket
   sockWrite(type, data) {
-    this.sockets.forEach(socket => {
-      this.send(socket, JSON.stringify({
-        type,
-        data
-      }));
+    this.sockets.forEach((socket) => {
+      this.send(socket, JSON.stringify({ type, data }));
     });
   }
   singleWrite(socket, type, data) {
-    this.send(socket, JSON.stringify({
-      type,
-      data
-    }));
+    this.send(socket, JSON.stringify({ type, data }));
   }
   close() {
-    this.sockets.forEach(socket => {
+    this.sockets.forEach((socket) => {
       socket.close();
     });
     if (this.timer) {
@@ -83,33 +64,29 @@ export default class SocketServer {
   onConnect(socket) {
     const connection = socket;
     connection.isAlive = true;
-    connection.on('pong', () => {
+    connection.on("pong", () => {
       connection.isAlive = true;
     });
     if (!connection) {
       return;
     }
     this.sockets.push(connection);
-    connection.on('close', () => {
+    connection.on("close", () => {
       const idx = this.sockets.indexOf(connection);
       if (idx >= 0) {
         this.sockets.splice(idx, 1);
       }
     });
-    if (this.options.hot || this.options.hot === 'only') {
-      this.singleWrite(connection, 'hot');
+    if (this.options.hot || this.options.hot === "only") {
+      this.singleWrite(connection, "hot");
     }
     if (this.options.liveReload) {
-      this.singleWrite(connection, 'liveReload');
+      this.singleWrite(connection, "liveReload");
     }
-
-    // send first stats to active client sock if stats exist
     if (this.stats) {
       this.sendStats(true);
     }
   }
-
-  // get standard stats
   getStats() {
     const curStats = this.stats;
     if (!curStats) {
@@ -125,34 +102,31 @@ export default class SocketServer {
     };
     return curStats.toJson(defaultStats);
   }
-
-  // determine what message should send by stats
   sendStats(force = false) {
     const stats = this.getStats();
-
-    // this should never happened
     if (!stats) {
       return null;
     }
-    const shouldEmit = !force && stats && (!stats.errors || stats.errors.length === 0) && stats.assets && stats.assets.every(asset => !asset.emitted);
+    const shouldEmit = !force && stats && (!stats.errors || stats.errors.length === 0) && stats.assets && stats.assets.every((asset) => !asset.emitted);
     if (shouldEmit) {
-      return this.sockWrite('still-ok');
+      return this.sockWrite("still-ok");
     }
-    this.sockWrite('hash', stats.hash);
+    this.sockWrite("hash", stats.hash);
     if (stats.errors && stats.errors.length > 0) {
-      return this.sockWrite('errors', stats.errors);
+      return this.sockWrite("errors", stats.errors);
     } else if (stats.warnings && stats.warnings.length > 0) {
-      return this.sockWrite('warnings', stats.warnings);
+      return this.sockWrite("warnings", stats.warnings);
     } else {
-      return this.sockWrite('ok');
+      return this.sockWrite("ok");
     }
   }
-
-  // send message to connecting socket
   send(connection, message) {
     if (connection.readyState !== 1) {
       return;
     }
     connection.send(message);
   }
-}
+}
+export {
+  SocketServer as default
+};

package/dist/js/modern/dev-tools/https/index.js

@@ -1,9 +1,32 @@
-import * as devcert from 'devcert';
-export const genHttpsOptions = async userOptions => {
-  const httpsOptions = typeof userOptions === 'boolean' ? {} : userOptions;
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+import * as devcert from "devcert";
+const genHttpsOptions = (userOptions) => __async(void 0, null, function* () {
+  const httpsOptions = typeof userOptions === "boolean" ? {} : userOptions;
   if (!httpsOptions.key || !httpsOptions.cert) {
-    const selfsign = await devcert.certificateFor(['localhost']);
+    const selfsign = yield devcert.certificateFor(["localhost"]);
     return selfsign;
   }
   return httpsOptions;
-};
+});
+export {
+  genHttpsOptions
+};

package/dist/js/modern/dev-tools/mock/getMockData.js

@@ -1,48 +1,78 @@
-function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
-function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
-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 { compatRequire } from '@modern-js/utils';
-import { match } from 'path-to-regexp';
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
-const VALID_METHODS = ['get', 'post', 'put', 'delete', 'patch'];
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
-const BODY_PARSED_METHODS = ['post', 'put', 'delete', 'patch'];
-const createFunctionDataHandler = (method, handler) => async (context, next) => {
-  const {
-    req,
-    res
-  } = context;
-  return handler(req, res, next);
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
 };
-const createStaticDataHandler = (method, handler) => context => {
-  const {
-    res
-  } = context;
-  res.setHeader('Content-Type', 'application/json');
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+import { compatRequire } from "@modern-js/utils";
+import { match } from "path-to-regexp";
+const VALID_METHODS = ["get", "post", "put", "delete", "patch"];
+const BODY_PARSED_METHODS = ["post", "put", "delete", "patch"];
+const createFunctionDataHandler = (method, handler) => (context, next) => __async(void 0, null, function* () {
+  const { req, res } = context;
+  return handler(req, res, next);
+});
+const createStaticDataHandler = (method, handler) => (context) => {
+  const { res } = context;
+  res.setHeader("Content-Type", "application/json");
   res.end(JSON.stringify(handler));
 };
-const allowTypes = ['object', 'function'];
-const normalizeConfig = mockConfig => Object.keys(mockConfig).reduce((acc, key) => {
+const allowTypes = ["object", "function"];
+const normalizeConfig = (mockConfig) => Object.keys(mockConfig).reduce((acc, key) => {
   const handler = mockConfig[key];
   const type = typeof handler;
   if (!allowTypes.includes(type)) {
-    throw new Error(`mock value of ${key} should be object or function, but got ${type}`);
+    throw new Error(
+      `mock value of ${key} should be object or function, but got ${type}`
+    );
   }
   const meta = parseKey(key);
-  if (type === 'object') {
-    acc.push(_objectSpread(_objectSpread({}, meta), {}, {
+  if (type === "object") {
+    acc.push(__spreadProps(__spreadValues({}, meta), {
       handler: createStaticDataHandler(meta.method, handler)
     }));
   } else {
-    acc.push(_objectSpread(_objectSpread({}, meta), {}, {
+    acc.push(__spreadProps(__spreadValues({}, meta), {
       handler: createFunctionDataHandler(meta.method, handler)
     }));
   }
   return acc;
 }, []);
-const _blank = ' ';
-const parseKey = key => {
-  // 'Method /pathname' | '/pathname'
+const _blank = " ";
+const parseKey = (key) => {
   const splitted = key.split(_blank).filter(Boolean);
   if (splitted.length > 1) {
     const [method, pathname] = splitted;
@@ -51,31 +81,23 @@ const parseKey = key => {
       path: pathname
     };
   }
-
-  // default return get method
   return {
-    method: 'get',
+    method: "get",
     path: key
   };
 };
-export default (filepath => {
+var getMockData_default = (filepath) => {
   const mockModule = compatRequire(filepath);
   if (!mockModule) {
     throw new Error(`Mock file ${filepath} parsed failed!`);
   }
   const data = normalizeConfig(mockModule);
   return data;
-});
-export const getMatched = (context, mockApiList) => {
-  const {
-    path: targetPathname,
-    method: targetMethod
-  } = context;
-  const matched = mockApiList.find(mockApi => {
-    const {
-      method,
-      path: pathname
-    } = mockApi;
+};
+const getMatched = (context, mockApiList) => {
+  const { path: targetPathname, method: targetMethod } = context;
+  const matched = mockApiList.find((mockApi) => {
+    const { method, path: pathname } = mockApi;
     if (method.toLowerCase() === targetMethod.toLowerCase()) {
       return match(pathname, {
         encode: encodeURI,
@@ -85,4 +107,8 @@ export const getMatched = (context, mockApiList) => {
     return false;
   });
   return matched;
-};
+};
+export {
+  getMockData_default as default,
+  getMatched
+};

package/dist/js/modern/dev-tools/mock/index.js

@@ -1,12 +1,30 @@
-import path from 'path';
-import { fs } from '@modern-js/utils';
-import { AGGRED_DIR } from '@modern-js/prod-server';
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+import path from "path";
+import { fs } from "@modern-js/utils";
+import { AGGRED_DIR } from "@modern-js/prod-server";
 import getMockData, { getMatched } from "./getMockData";
-export const createMockHandler = ({
-  pwd
-}) => {
-  const exts = ['.ts', '.js'];
-  let filepath = '';
+const createMockHandler = ({ pwd }) => {
+  const exts = [".ts", ".js"];
+  let filepath = "";
   for (const ext of exts) {
     const maybeMatch = path.join(pwd, `${AGGRED_DIR.mock}/index${ext}`);
     if (fs.existsSync(maybeMatch)) {
@@ -21,15 +39,16 @@ export const createMockHandler = ({
   if (!apiList || apiList.length === 0) {
     return null;
   }
-  return async (context, next) => {
-    const {
-      res
-    } = context;
+  return (context, next) => __async(void 0, null, function* () {
+    const { res } = context;
     const matched = getMatched(context, apiList);
     if (!matched) {
       return next();
     }
-    res.setHeader('Access-Control-Allow-Origin', '*');
+    res.setHeader("Access-Control-Allow-Origin", "*");
     return matched.handler(context, next);
-  };
-};
+  });
+};
+export {
+  createMockHandler
+};