@modern-js/server 1.17.0 → 1.18.1-alpha.0

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/https/index.js

@@ -12,7 +12,7 @@ function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "functio
 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; }
 
 const genHttpsOptions = async userOptions => {
-  const httpsOptions = userOptions === true ? {} : userOptions;
+  const httpsOptions = typeof userOptions === 'boolean' ? {} : userOptions;
 
   if (!httpsOptions.key || !httpsOptions.cert) {
     const selfsign = await devcert.certificateFor(['localhost']);

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

@@ -0,0 +1,120 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.enableRegister = void 0;
+
+var _path = _interopRequireDefault(require("path"));
+
+var _serverUtils = require("@modern-js/server-utils");
+
+var _utils = require("@modern-js/utils");
+
+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 debug = (0, _utils.createDebugger)('server');
+
+const checkDep = (depName, paths) => {
+  let packagePath = '';
+
+  try {
+    packagePath = require.resolve(depName, {
+      paths
+    });
+  } catch (error) {}
+
+  return Boolean(packagePath);
+};
+
+const enableRegister = (projectRoot, config // eslint-disable-next-line consistent-return
+) => {
+  const registerDirs = ['./api', './server', './config/mock', './shared'];
+  const TS_CONFIG_FILENAME = `tsconfig.json`;
+
+  const tsconfigPath = _path.default.resolve(projectRoot, TS_CONFIG_FILENAME);
+
+  const isTsProject = _utils.fs.existsSync(tsconfigPath);
+
+  const existTsNode = checkDep('ts-node', [projectRoot]);
+  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');
+
+    const tsConfigPaths = require('tsconfig-paths');
+
+    const {
+      alias
+    } = config.source;
+    const aliasOption = (0, _utils.getAlias)(alias || {}, {
+      appDirectory: projectRoot,
+      tsconfigPath
+    });
+    const {
+      paths = {},
+      absoluteBaseUrl = './'
+    } = aliasOption;
+    const tsPaths = Object.keys(paths).reduce((o, key) => {
+      let tsPath = paths[key];
+
+      if (typeof tsPath === 'string' && _path.default.isAbsolute(tsPath)) {
+        tsPath = _path.default.relative(absoluteBaseUrl, tsPath);
+      }
+
+      if (typeof tsPath === 'string') {
+        tsPath = [tsPath];
+      }
+
+      return _objectSpread(_objectSpread({}, o), {}, {
+        [`${key}`]: tsPath
+      });
+    }, {});
+    tsConfigPaths.register({
+      baseUrl: absoluteBaseUrl || './',
+      paths: tsPaths
+    });
+    tsNode.register({
+      project: tsconfigPath,
+      // for env.d.ts, https://www.npmjs.com/package/ts-node#missing-types
+      files: true,
+      transpileOnly: true,
+      ignore: ['(?:^|/)node_modules/', `(?:^|/)${distPath}/bundles/`]
+    });
+  } else {
+    debug('use @babel/register');
+    const babelConfig = (0, _serverUtils.resolveBabelConfig)(projectRoot, config, {
+      tsconfigPath,
+      syntax: 'es6+',
+      type: 'commonjs'
+    });
+    return require('@babel/register')(_objectSpread(_objectSpread({}, babelConfig), {}, {
+      only: [function (filePath) {
+        // TODO: wait params
+        // FIXME: 删除hardcode，根据 AppContext 中的 metaName 设置路径
+        if (filePath.includes(`node_modules${_path.default.sep}.modern-js`)) {
+          return true;
+        }
+
+        return registerDirs.some(registerDir => filePath.startsWith(_path.default.join(projectRoot, registerDir)));
+      }],
+      extensions: ['.js', '.ts'],
+      babelrc: false,
+      configFile: false,
+      root: projectRoot
+    }));
+  }
+};
+
+exports.enableRegister = enableRegister;

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/babel/register");
+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/https/index.d.ts

@@ -1 +1,6 @@
-export declare const genHttpsOptions: (userOptions: any) => Promise<any>;
+import type Buffer from 'buffer';
+import type { DevServerHttpsOptions } from '../../types';
+export declare const genHttpsOptions: (userOptions: DevServerHttpsOptions) => Promise<{
+  key?: Buffer | string;
+  cert?: Buffer | string;
+}>;

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 { ModernDevServerOptions } from './types';
+import type { DevServerOptions, DevServerHttpsOptions, ModernDevServerOptions } from './types';
 export { Server };
-export type { ModernDevServerOptions };
+export type { DevServerOptions, DevServerHttpsOptions, ModernDevServerOptions };
 
 declare const _default: (options: ModernDevServerOptions) => Promise<Server>;