@modern-js/server 1.18.0 → 1.18.1

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

@@ -0,0 +1,152 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _events = require("events");
+
+var _webpackDevMiddleware = _interopRequireDefault(require("@modern-js/utils/webpack-dev-middleware"));
+
+var _devServerPlugin = _interopRequireDefault(require("./dev-server-plugin"));
+
+var _socketServer = _interopRequireDefault(require("./socket-server"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+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; }
+
+const noop = () => {// noop
+};
+
+class DevMiddleware extends _events.EventEmitter {
+  constructor({
+    compiler,
+    dev,
+    config
+  }) {
+    super();
+
+    _defineProperty(this, "middleware", void 0);
+
+    _defineProperty(this, "compiler", void 0);
+
+    _defineProperty(this, "devOptions", void 0);
+
+    _defineProperty(this, "socketServer", void 0);
+
+    _defineProperty(this, "config", void 0);
+
+    this.compiler = compiler;
+    this.devOptions = dev;
+    this.config = config; // init socket server
+
+    this.socketServer = new _socketServer.default(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();
+    }
+  }
+
+  init(app) {
+    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);
+      this.socketServer.close();
+    });
+  }
+
+  setupDevServerPlugin() {
+    const {
+      devOptions
+    } = this; // apply dev server to client compiler, add hmr client to entry.
+
+    if (this.compiler.compilers) {
+      this.compiler.compilers.forEach(target => {
+        if (this.isClientCompiler(target)) {
+          new _devServerPlugin.default(devOptions).apply(target);
+        }
+      });
+    } else {
+      new _devServerPlugin.default(devOptions).apply(this.compiler);
+    }
+  }
+
+  setupHooks() {
+    const invalidPlugin = () => {
+      this.socketServer.sockWrite('invalid');
+    };
+
+    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 => {
+        this.socketServer.updateStats(stats);
+        this.emit('change', stats);
+      });
+    };
+
+    if (this.compiler.compilers) {
+      this.compiler.compilers.forEach(addHooks);
+    } else {
+      addHooks(this.compiler);
+    }
+  }
+
+  setupDevMiddleware() {
+    var _config$tools, _config$tools$devServ;
+
+    const {
+      config,
+      devOptions
+    } = this;
+    const middleware = (0, _webpackDevMiddleware.default)(this.compiler, _objectSpread({
+      headers: (_config$tools = config.tools) === null || _config$tools === void 0 ? void 0 : (_config$tools$devServ = _config$tools.devServer) === null || _config$tools$devServ === void 0 ? void 0 : _config$tools$devServ.headers,
+      stats: false
+    }, devOptions.devMiddleware));
+    return middleware;
+  }
+
+  isClientCompiler(compiler) {
+    const {
+      target
+    } = compiler.options; // if target not contains `node`, it's a client compiler
+
+    if (target) {
+      if (Array.isArray(target)) {
+        return !target.includes('node');
+      }
+
+      return target !== 'node';
+    }
+
+    return compiler.name === 'client';
+  }
+
+}
+
+exports.default = DevMiddleware;

package/dist/js/node/dev-tools/{socket-server.js → dev-middleware/socket-server.js}

@@ -32,10 +32,12 @@ class SocketServer {
 
 
   prepare(app) {
+    var _this$options$client;
+
     this.app = app;
     this.wsServer = new _ws.default.Server({
       noServer: true,
-      path: this.options.client.path
+      path: (_this$options$client = this.options.client) === null || _this$options$client === void 0 ? void 0 : _this$options$client.path
     }); // listen upgrade event to handle socket
 
     this.app.on('upgrade', (req, sock, head) => {
@@ -103,6 +105,8 @@ class SocketServer {
   }
 
   onConnect(socket) {
+    var _this$options$client2, _this$options$client3, _this$options$client4;
+
     const connection = socket;
     connection.isAlive = true;
     connection.on('pong', () => {
@@ -122,7 +126,7 @@ class SocketServer {
       }
     });
 
-    if (this.options.client.logging) {
+    if ((_this$options$client2 = this.options.client) !== null && _this$options$client2 !== void 0 && _this$options$client2.logging) {
       this.singleWrite(connection, 'logging', this.options.client.logging);
     }
 
@@ -134,11 +138,11 @@ class SocketServer {
       this.singleWrite(connection, 'liveReload');
     }
 
-    if (this.options.client.progress) {
+    if ((_this$options$client3 = this.options.client) !== null && _this$options$client3 !== void 0 && _this$options$client3.progress) {
       this.singleWrite(connection, 'progress', this.options.client.progress);
     }
 
-    if (this.options.client.overlay) {
+    if ((_this$options$client4 = this.options.client) !== null && _this$options$client4 !== void 0 && _this$options$client4.overlay) {
       this.singleWrite(connection, 'overlay', this.options.client.overlay);
     } // send first stats to active client sock if stats exist
 

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

@@ -46,7 +46,10 @@ const enableRegister = (projectRoot, config // eslint-disable-next-line consiste
   const existTsConfigPaths = checkDep('tsconfig-paths', [projectRoot]);
 
   if (isTsProject && existTsNode && existTsConfigPaths) {
+    var _config$output;
+
     debug('use ts-node');
+    const distPath = (config === null || config === void 0 ? void 0 : (_config$output = config.output) === null || _config$output === void 0 ? void 0 : _config$output.path) || 'dist';
 
     const tsNode = require('ts-node');
 
@@ -86,7 +89,8 @@ const enableRegister = (projectRoot, config // eslint-disable-next-line consiste
       project: tsconfigPath,
       // for env.d.ts, https://www.npmjs.com/package/ts-node#missing-types
       files: true,
-      transpileOnly: true
+      transpileOnly: true,
+      ignore: ['(?:^|/)node_modules/', `(?:^|/)${distPath}/bundles/`]
     });
   } else {
     debug('use @babel/register');

package/dist/js/node/server/dev-server.js

@@ -13,22 +13,18 @@ var _https = require("https");
 
 var _utils = require("@modern-js/utils");
 
-var _webpackDevMiddleware = _interopRequireDefault(require("@modern-js/utils/webpack-dev-middleware"));
-
 var _prodServer = require("@modern-js/prod-server");
 
 var _constants = require("../constants");
 
 var _mock = require("../dev-tools/mock");
 
-var _socketServer = _interopRequireDefault(require("../dev-tools/socket-server"));
-
-var _devServerPlugin = _interopRequireDefault(require("../dev-tools/dev-server-plugin"));
-
 var _register = require("../dev-tools/register");
 
 var _watcher = _interopRequireWildcard(require("../dev-tools/watcher"));
 
+var _devMiddleware = _interopRequireDefault(require("../dev-tools/dev-middleware"));
+
 function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
 
 function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
@@ -49,19 +45,19 @@ class ModernDevServer extends _prodServer.ModernServer {
 
     _defineProperty(this, "dev", void 0);
 
-    _defineProperty(this, "compiler", void 0);
-
-    _defineProperty(this, "socketServer", void 0);
+    _defineProperty(this, "devMiddleware", void 0);
 
     _defineProperty(this, "watcher", void 0);
 
-    _defineProperty(this, "devMiddleware", void 0);
-
-    this.workDir = this.pwd; // set webpack compiler
+    this.workDir = this.pwd; // set dev server options, like webpack-dev-server
 
-    this.compiler = options.compiler; // set dev server options, like webpack-dev-server
+    this.dev = this.getDevOptions(options); // create dev middleware instance
 
-    this.dev = this.getDevOptions(options);
+    this.devMiddleware = new _devMiddleware.default({
+      dev: this.dev,
+      compiler: options.compiler,
+      config: this.conf
+    });
     (0, _register.enableRegister)(this.pwd, this.conf);
   }
 
@@ -74,15 +70,15 @@ class ModernDevServer extends _prodServer.ModernServer {
   } // Complete the preparation of services
 
 
-  async onInit(runner) {
+  async onInit(runner, app) {
     var _conf$tools, _conf$tools$devServer;
 
     this.runner = runner;
     const {
       conf,
       pwd,
-      compiler,
-      dev
+      dev,
+      devMiddleware
     } = this; // before dev handler
 
     const beforeHandlers = await this.setupBeforeDevMiddleware();
@@ -136,14 +132,29 @@ class ModernDevServer extends _prodServer.ModernServer {
     } // do webpack build / plugin apply / socket server when pass compiler instance
 
 
-    if (compiler) {
-      // init socket server
-      this.socketServer = new _socketServer.default(dev); // setup compiler in server, also add dev-middleware to handler static file in memory
-
-      const devMiddlewareHandler = this.setupCompiler(compiler);
-      this.addHandler(devMiddlewareHandler);
-    } // after dev handler
+    devMiddleware.init(app);
+    devMiddleware.on('change', stats => {
+      // Reset only when client compile done
+      if (stats.toJson({
+        all: false
+      }).name === 'client') {
+        this.onRepack({
+          routes: this.getRoutes()
+        });
+      }
+    });
+    this.addHandler((ctx, next) => {
+      const {
+        req,
+        res
+      } = ctx;
 
+      if (devMiddleware.middleware) {
+        devMiddleware.middleware(req, res, next);
+      } else {
+        next();
+      }
+    }); // after dev handler
 
     const afterHandlers = await this.setupAfterDevMiddleware();
     afterHandlers.forEach(handler => {
@@ -155,28 +166,16 @@ class ModernDevServer extends _prodServer.ModernServer {
         return handler(req, res, next);
       });
     });
-    await super.onInit(runner); // watch mock/ server/ api/ dir file change
+    await super.onInit(runner, app); // watch mock/ server/ api/ dir file change
 
     if (dev.watch) {
       this.startWatcher();
-    }
-  }
+      app.on('close', async () => {
+        var _this$watcher;
 
-  async onClose() {
-    var _this$watcher, _this$socketServer;
-
-    await super.onClose();
-    await ((_this$watcher = this.watcher) === null || _this$watcher === void 0 ? void 0 : _this$watcher.close());
-    await new Promise(resolve => {
-      if (this.devMiddleware) {
-        this.devMiddleware.close(() => {
-          resolve();
-        });
-      } else {
-        resolve();
-      }
-    });
-    (_this$socketServer = this.socketServer) === null || _this$socketServer === void 0 ? void 0 : _this$socketServer.close();
+        await ((_this$watcher = this.watcher) === null || _this$watcher === void 0 ? void 0 : _this$watcher.close());
+      });
+    }
   }
 
   onRepack(options = {}) {
@@ -192,12 +191,6 @@ class ModernDevServer extends _prodServer.ModernServer {
     super.onRepack(options);
   }
 
-  onListening(app) {
-    var _this$socketServer2;
-
-    (_this$socketServer2 = this.socketServer) === null || _this$socketServer2 === void 0 ? void 0 : _this$socketServer2.prepare(app);
-  }
-
   async createHTTPServer(handler) {
     const {
       dev
@@ -257,104 +250,12 @@ class ModernDevServer extends _prodServer.ModernServer {
         this.logger.error(e);
       }
     }
-  } // set up plugin to each compiler
-  // register hooks for each compilation, update socket stats if recompiled
-  // start dev middleware
-
-
-  setupCompiler(compiler) {
-    this.setupDevServerPlugin(compiler);
-    this.setupHooks();
-    return this.setupDevMiddleware(compiler);
   }
 
-  isClientCompiler(compiler) {
-    const {
-      target
-    } = compiler.options; // if target not contains `node`, it's a client compiler
-
-    if (target) {
-      if (Array.isArray(target)) {
-        return !target.includes('node');
-      }
-
-      return target !== 'node';
-    }
-
-    return compiler.name === 'client';
-  }
-
-  setupDevServerPlugin(compiler) {
-    const {
-      dev: devConf
-    } = this; // apply dev server to client compiler, add hmr client to entry.
-
-    if (compiler.compilers) {
-      compiler.compilers.forEach(target => {
-        if (this.isClientCompiler(target)) {
-          new _devServerPlugin.default(devConf).apply(target);
-        }
-      });
-    } else {
-      new _devServerPlugin.default(devConf).apply(compiler);
-    }
-  }
-
-  setupHooks() {
-    const invalidPlugin = () => {
-      this.socketServer.sockWrite('invalid');
-    };
-
-    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 => {
-        this.socketServer.updateStats(stats); // Reset only when client compile done
-
-        if (stats.toJson({
-          all: false
-        }).name === 'client') {
-          this.onRepack({
-            routes: this.getRoutes()
-          });
-        }
-      });
-    };
-
-    if (this.compiler.compilers) {
-      this.compiler.compilers.forEach(addHooks);
-    } else {
-      addHooks(this.compiler);
-    }
-  }
-
-  setupDevMiddleware(compiler) {
-    var _conf$tools2, _conf$tools2$devServe;
-
-    const {
-      conf
-    } = this;
-    this.devMiddleware = (0, _webpackDevMiddleware.default)(compiler, _objectSpread({
-      headers: (_conf$tools2 = conf.tools) === null || _conf$tools2 === void 0 ? void 0 : (_conf$tools2$devServe = _conf$tools2.devServer) === null || _conf$tools2$devServe === void 0 ? void 0 : _conf$tools2$devServe.headers,
-      publicPath: '/',
-      stats: false
-    }, this.dev.devMiddleware));
-    return (ctx, next) => {
-      const {
-        req,
-        res
-      } = ctx;
-      this.devMiddleware(req, res, next);
-    };
+  createContext(req, res) {
+    return super.createContext(req, res, {
+      etag: true
+    });
   }
 
   async setupBeforeDevMiddleware() {

package/dist/js/node/server/index.js

@@ -9,16 +9,8 @@ var _prodServer = require("@modern-js/prod-server");
 
 var _devServer = require("./dev-server");
 
-var _devServerSplit = require("./dev-server-split");
-
 const createDevServer = options => {
-  if (options.apiOnly) {
-    return new _devServerSplit.ModernAPIDevServer(options);
-  } else if (options.ssrOnly) {
-    return new _devServerSplit.ModernSSRDevServer(options);
-  } else {
-    return new _devServer.ModernDevServer(options);
-  }
+  return new _devServer.ModernDevServer(options);
 };
 
 class DevServer extends _prodServer.Server {

package/dist/types/dev-tools/{dev-server-plugin.d.ts → dev-middleware/dev-server-plugin.d.ts}

@@ -1,5 +1,5 @@
 import type webpack from 'webpack';
-import type { DevServerOptions } from '../types';
+import type { DevServerOptions } from '../../types';
 export default class DevServerPlugin {
   private readonly options;
   constructor(options: DevServerOptions);

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

@@ -0,0 +1,31 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { Server, IncomingMessage, ServerResponse } from 'http';
+import { EventEmitter } from 'events';
+import { Compiler, MultiCompiler } from 'webpack';
+import webpackDevMiddleware from '@modern-js/utils/webpack-dev-middleware';
+import type { NormalizedConfig } from '@modern-js/core';
+import { DevServerOptions } from '../../types';
+declare type Options = {
+  compiler: MultiCompiler | Compiler | null;
+  dev: DevServerOptions;
+  config: NormalizedConfig;
+};
+export default class DevMiddleware extends EventEmitter {
+  middleware?: webpackDevMiddleware.API<IncomingMessage, ServerResponse>;
+  private compiler;
+  private devOptions;
+  private socketServer;
+  private config;
+  constructor({
+    compiler,
+    dev,
+    config
+  }: Options);
+  init(app: Server): void;
+  private setupDevServerPlugin;
+  private setupHooks;
+  private setupDevMiddleware;
+  private isClientCompiler;
+}
+export {};

package/dist/types/dev-tools/{socket-server.d.ts → dev-middleware/socket-server.d.ts}

@@ -2,7 +2,7 @@
 import { Server } from 'http';
 import ws from 'ws';
 import type webpack from 'webpack';
-import type { DevServerOptions } from '../types';
+import type { DevServerOptions } from '../../types';
 export default class SocketServer {
   private wsServer;
   private readonly sockets;

package/dist/types/dev-tools/mock/getMockData.d.ts

@@ -1,6 +1,6 @@
 /// <reference types="node" />
 import { IncomingMessage, ServerResponse } from 'http';
-import { ModernServerContext, NextFunction } from '@modern-js/types';
+import type { ModernServerContext, NextFunction } from '@modern-js/types';
 export declare type MockConfig = Record<string, {
   data: any;
 } | ((req: IncomingMessage, res: ServerResponse, next: NextFunction) => Promise<void>)>;

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

@@ -1,4 +1,4 @@
-import { ModernServerContext, NextFunction } from '@modern-js/types';
+import type { ModernServerContext, NextFunction } from '@modern-js/types';
 export declare const createMockHandler: ({
   pwd
 }: {

package/dist/types/index.d.ts

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

package/dist/types/server/dev-server.d.ts

@@ -1,23 +1,19 @@
 /// <reference types="node" />
 /// <reference types="node" />
-import http, { Server, IncomingMessage, ServerResponse } from 'http';
+import { IncomingMessage, Server, ServerResponse } from 'http';
 import { ServerHookRunner, ModernServer, BuildOptions } from '@modern-js/prod-server';
 import { WatchEvent } from '../dev-tools/watcher';
-import { ModernDevServerOptions } from '../types';
+import type { ModernDevServerOptions } from '../types';
 export declare class ModernDevServer extends ModernServer {
   private mockHandler;
   private readonly dev;
-  private readonly compiler?;
-  private socketServer;
+  private readonly devMiddleware;
   private watcher?;
-  private devMiddleware;
   constructor(options: ModernDevServerOptions);
   private getDevOptions;
-  onInit(runner: ServerHookRunner): Promise<void>;
-  onClose(): Promise<void>;
+  onInit(runner: ServerHookRunner, app: Server): Promise<void>;
   onRepack(options?: BuildOptions): void;
-  onListening(app: Server): void;
-  createHTTPServer(handler: (req: IncomingMessage, res: ServerResponse, next?: () => void) => void): Promise<http.Server | import("https").Server>;
+  createHTTPServer(handler: (req: IncomingMessage, res: ServerResponse, next?: () => void) => void): Promise<Server | import("https").Server>;
   protected warmupSSRBundle(): void;
   protected onServerChange({
     filepath,
@@ -26,11 +22,7 @@ export declare class ModernDevServer extends ModernServer {
     filepath: string;
     event: WatchEvent;
   }): void;
-  private setupCompiler;
-  private isClientCompiler;
-  private setupDevServerPlugin;
-  private setupHooks;
-  private setupDevMiddleware;
+  protected createContext(req: IncomingMessage, res: ServerResponse): import("@modern-js/prod-server/src/libs/context").ModernServerContext;
   private setupBeforeDevMiddleware;
   private setupAfterDevMiddleware;
   private cleanSSRCache;

package/dist/types/server/index.d.ts

@@ -1,5 +1,5 @@
 import { Server } from '@modern-js/prod-server';
-import { ModernDevServerOptions } from '../types';
+import type { ModernDevServerOptions } from '../types';
 export declare class DevServer extends Server {
   constructor(options: ModernDevServerOptions);
 }

package/dist/types/types.d.ts

@@ -1,29 +1,9 @@
 import type webpack from 'webpack';
+import type { DevServerOptions, DevServerHttpsOptions } from '@modern-js/types';
 import type { ModernServerOptions } from '@modern-js/prod-server';
-export declare type DevServerHttpsOptions = boolean | {
-  key: string;
-  cert: string;
-};
-export declare type DevServerOptions = {
-  client: {
-    path?: string;
-    port?: string;
-    host?: string;
-    logging?: string;
-    overlay?: boolean;
-    progress?: boolean;
-  };
-  devMiddleware: {
-    writeToDisk: boolean | ((filename: string) => boolean);
-  };
-  watch: boolean;
-  hot: boolean | string;
-  liveReload: boolean;
-  https?: DevServerHttpsOptions;
-  [propName: string]: any;
-};
+export type { DevServerOptions, DevServerHttpsOptions };
 export declare type ExtraOptions = {
-  dev?: boolean | Partial<DevServerOptions>;
-  compiler?: webpack.MultiCompiler | webpack.Compiler | null;
+  dev: boolean | Partial<DevServerOptions>;
+  compiler: webpack.MultiCompiler | webpack.Compiler | null;
 };
 export declare type ModernDevServerOptions = ModernServerOptions & ExtraOptions;