@bleedingdev/modern-js-server 3.2.0-ultramodern.0

package/dist/esm-node/dev-tools/watcher/index.mjs

@@ -0,0 +1,93 @@
+import __rslib_shim_module__ from "node:module";
+const require = /*#__PURE__*/ __rslib_shim_module__.createRequire(/*#__PURE__*/ (()=>import.meta.url)());
+import { chokidar, fs } from "@modern-js/utils";
+import path from "path";
+import { DependencyTree } from "./dependencyTree.mjs";
+import { StatsCache } from "./statsCache.mjs";
+const defaultWatchOptions = {
+    ignoreInitial: true,
+    ignored: /api\/typings\/.*/
+};
+const getWatchedFiles = (watcher)=>{
+    const watched = watcher.getWatched();
+    const files = [];
+    Object.keys(watched).forEach((dir)=>{
+        const dirFiles = watched[dir];
+        if (!dirFiles) return;
+        dirFiles.forEach((fileName)=>{
+            files.push(path.join(dir, fileName));
+        });
+    });
+    return files;
+};
+const mergeWatchOptions = (options)=>{
+    const watchOptions = {
+        ...options
+    };
+    if (watchOptions) {
+        const { ignored } = watchOptions;
+        const finalIgnored = ignored ? [
+            defaultWatchOptions.ignored,
+            ...Array.isArray(ignored) ? ignored : [
+                ignored
+            ]
+        ] : ignored;
+        if (finalIgnored) watchOptions.ignored = finalIgnored;
+    }
+    const finalWatchOptions = {
+        ...defaultWatchOptions,
+        ...watchOptions
+    };
+    return finalWatchOptions;
+};
+class Watcher {
+    listen(files, options, callback) {
+        const watched = files.filter(Boolean);
+        const filenames = watched.map((filename)=>filename.replace(/\\/g, '/'));
+        const cache = new StatsCache();
+        const watcher = chokidar.watch(filenames, options);
+        watcher.on('ready', ()=>{
+            cache.add(getWatchedFiles(watcher));
+        });
+        watcher.on('change', (changed)=>{
+            if (!fs.existsSync(changed) || cache.isDiff(changed)) {
+                cache.refresh(changed);
+                callback(changed, 'change');
+            }
+        });
+        watcher.on('add', (changed)=>{
+            if (!cache.has(changed)) {
+                cache.add([
+                    changed
+                ]);
+                callback(changed, 'add');
+            }
+        });
+        watcher.on('unlink', (changed)=>{
+            cache.del(changed);
+            callback(changed, 'unlink');
+        });
+        this.watcher = watcher;
+    }
+    createDepTree() {
+        this.dependencyTree = new DependencyTree();
+    }
+    updateDepTree() {
+        this.dependencyTree?.update(require.cache);
+    }
+    cleanDepCache(filepath) {
+        const node = this.dependencyTree?.getNode(filepath);
+        if (node && require.cache[filepath]) {
+            delete require.cache[filepath];
+            for (const parentNode of node.parent.values())this.cleanDepCache(parentNode.module.filename);
+        }
+    }
+    close() {
+        return this.watcher.close();
+    }
+    constructor(){
+        this.dependencyTree = null;
+    }
+}
+export default Watcher;
+export { defaultWatchOptions, getWatchedFiles, mergeWatchOptions };

package/dist/esm-node/dev-tools/watcher/statsCache.mjs

@@ -0,0 +1,51 @@
+import "node:module";
+import crypto_0 from "crypto";
+import fs from "fs";
+class StatsCache {
+    add(files) {
+        const { cachedHash, cachedSize } = this;
+        for (const filename of files)if (fs.existsSync(filename)) {
+            const stats = fs.statSync(filename);
+            if (stats.isFile() && !cachedHash[filename]) {
+                cachedHash[filename] = this.hash(stats, filename);
+                cachedSize[filename] = stats.size;
+            }
+        }
+    }
+    refresh(filename) {
+        const { cachedHash, cachedSize } = this;
+        if (fs.existsSync(filename)) {
+            const stats = fs.statSync(filename);
+            if (stats.isFile()) {
+                cachedHash[filename] = this.hash(stats, filename);
+                cachedSize[filename] = stats.size;
+            }
+        }
+    }
+    del(filename) {
+        if (this.cachedHash[filename]) {
+            delete this.cachedHash[filename];
+            delete this.cachedSize[filename];
+        }
+    }
+    isDiff(filename) {
+        const { cachedHash, cachedSize } = this;
+        const stats = fs.statSync(filename);
+        const hash = cachedHash[filename];
+        const size = cachedSize[filename];
+        if (stats.size !== size) return true;
+        if (this.hash(stats, filename) !== hash) return true;
+        return false;
+    }
+    has(filename) {
+        return Boolean(this.cachedHash[filename]);
+    }
+    hash(stats, filename) {
+        return crypto_0.createHash('md5').update(fs.readFileSync(filename)).digest('hex');
+    }
+    constructor(){
+        this.cachedHash = {};
+        this.cachedSize = {};
+    }
+}
+export { StatsCache };

package/dist/esm-node/dev.mjs

@@ -0,0 +1,78 @@
+import "node:module";
+import { connectMid2HonoMid } from "@modern-js/server-core/node";
+import { API_DIR, SHARED_DIR } from "@modern-js/utils";
+import { getDevOptions, getMockMiddleware, initFileReader, onRepack, startWatcher } from "./helpers/index.mjs";
+const devPlugin = (options, compiler)=>({
+        name: '@modern-js/plugin-dev',
+        setup (api) {
+            const { config, pwd, builder, builderDevServer } = options;
+            const closeCb = [];
+            const dev = getDevOptions(options.dev);
+            api.onPrepare(async ()=>{
+                const { middlewares: builderMiddlewares, close, connectWebSocket } = builderDevServer || {};
+                close && closeCb.push(close);
+                const { middlewares, distDirectory, nodeServer, apiDirectory, sharedDirectory, serverBase } = api.getServerContext();
+                connectWebSocket && nodeServer && connectWebSocket({
+                    server: nodeServer
+                });
+                const hooks = api.getHooks();
+                builder?.onDevCompileDone(({ stats })=>{
+                    if ('server' !== stats.toJson({
+                        all: false
+                    }).name) onRepack(distDirectory, hooks);
+                });
+                const { watchOptions } = config.server;
+                const watcher = startWatcher({
+                    pwd,
+                    distDir: distDirectory,
+                    apiDir: apiDirectory || API_DIR,
+                    sharedDir: sharedDirectory || SHARED_DIR,
+                    watchOptions,
+                    server: serverBase
+                });
+                closeCb.push(watcher.close.bind(watcher));
+                closeCb.length > 0 && nodeServer?.on('close', ()=>{
+                    closeCb.forEach((cb)=>{
+                        cb();
+                    });
+                });
+                const before = [];
+                const after = [];
+                const { setupMiddlewares = [] } = dev;
+                setupMiddlewares.forEach((handler)=>{
+                    handler({
+                        unshift: (...handlers)=>before.unshift(...handlers),
+                        push: (...handlers)=>after.push(...handlers)
+                    }, {
+                        sockWrite: ()=>{}
+                    });
+                });
+                before.forEach((middleware, index)=>{
+                    middlewares.push({
+                        name: `before-dev-server-${index}`,
+                        handler: connectMid2HonoMid(middleware)
+                    });
+                });
+                const mockMiddleware = await getMockMiddleware(pwd);
+                middlewares.push({
+                    name: 'mock-dev',
+                    handler: mockMiddleware
+                });
+                builderMiddlewares && middlewares.push({
+                    name: 'rsbuild-dev',
+                    handler: connectMid2HonoMid(builderMiddlewares)
+                });
+                after.forEach((middleware, index)=>{
+                    middlewares.push({
+                        name: `after-dev-server-${index}`,
+                        handler: connectMid2HonoMid(middleware)
+                    });
+                });
+                middlewares.push({
+                    name: 'init-file-reader',
+                    handler: initFileReader(compiler)
+                });
+            });
+        }
+    });
+export { devPlugin };

package/dist/esm-node/helpers/devOptions.mjs

@@ -0,0 +1,25 @@
+import "node:module";
+const getDevOptions = (devOptions)=>{
+    const defaultOptions = {
+        https: false,
+        server: {}
+    };
+    return {
+        ...defaultOptions,
+        ...devOptions
+    };
+};
+const getDevAssetPrefix = (builder)=>new Promise((resolve)=>{
+        if (!builder) return resolve('');
+        builder?.onAfterCreateCompiler((params)=>{
+            let webCompiler;
+            webCompiler = 'compilers' in params.compiler ? params.compiler.compilers.find((c)=>'web' === c.name || 'client' === c.name) : params.compiler;
+            const publicPath = webCompiler?.options?.output?.publicPath;
+            if (publicPath && 'string' == typeof publicPath) {
+                const formatPublicPath = publicPath.replace(/^https?:\/\/[^/]+/, '');
+                return resolve(formatPublicPath);
+            }
+            return resolve('');
+        });
+    });
+export { getDevAssetPrefix, getDevOptions };

package/dist/esm-node/helpers/fileReader.mjs

@@ -0,0 +1,20 @@
+import "node:module";
+import { fileReader } from "@modern-js/runtime-utils/fileReader";
+const initFileReader = (compiler)=>{
+    let isInit = false;
+    return async (ctx, next)=>{
+        if (isInit) return next();
+        isInit = true;
+        const { res } = ctx.env.node;
+        if (!compiler) {
+            fileReader.reset();
+            return next();
+        }
+        const resolvedCompiler = 'compilers' in compiler ? compiler.compilers[0] : compiler;
+        const outputFileSystem = resolvedCompiler?.outputFileSystem;
+        if (outputFileSystem) fileReader.reset(outputFileSystem);
+        else fileReader.reset();
+        return next();
+    };
+};
+export { initFileReader };

package/dist/esm-node/helpers/index.mjs

@@ -0,0 +1,67 @@
+import __rslib_shim_module__ from "node:module";
+const require = /*#__PURE__*/ __rslib_shim_module__.createRequire(/*#__PURE__*/ (()=>import.meta.url)());
+import { AGGRED_DIR } from "@modern-js/server-core";
+import { SERVER_BUNDLE_DIRECTORY, SERVER_DIR, logger } from "@modern-js/utils";
+import path from "path";
+import dev_tools_watcher, { mergeWatchOptions } from "../dev-tools/watcher/index.mjs";
+import { initOrUpdateMockMiddlewares } from "./mock.mjs";
+import { debug } from "./utils.mjs";
+export * from "./devOptions.mjs";
+export * from "./fileReader.mjs";
+export * from "./mock.mjs";
+export * from "./repack.mjs";
+async function onServerChange({ pwd, filepath, event, server }) {
+    const { mock } = AGGRED_DIR;
+    const mockPath = path.normalize(path.join(pwd, mock));
+    const { hooks } = server;
+    if (filepath.startsWith(mockPath)) {
+        await initOrUpdateMockMiddlewares(pwd);
+        logger.info('Finish update the mock handlers');
+    } else try {
+        const fileChangeEvent = {
+            type: 'file-change',
+            payload: [
+                {
+                    filename: filepath,
+                    event
+                }
+            ]
+        };
+        await hooks.onReset.call({
+            event: fileChangeEvent
+        });
+        debug(`Finish reload server, trigger by ${filepath} ${event}`);
+    } catch (e) {
+        logger.error(e);
+    }
+}
+function startWatcher({ pwd, distDir, apiDir, sharedDir, watchOptions, server }) {
+    const { mock } = AGGRED_DIR;
+    const defaultWatched = [
+        `${mock}/**/*`,
+        `${SERVER_DIR}/**/*`,
+        `${apiDir}/**`,
+        `${sharedDir}/**/*`,
+        `${distDir}/${SERVER_BUNDLE_DIRECTORY}/*-server-loaders.js`
+    ];
+    const mergedWatchOptions = mergeWatchOptions(watchOptions);
+    const defaultWatchedPaths = defaultWatched.map((p)=>{
+        const finalPath = path.isAbsolute(p) ? p : path.join(pwd, p);
+        return path.normalize(finalPath);
+    });
+    const watcher = new dev_tools_watcher();
+    watcher.createDepTree();
+    watcher.listen(defaultWatchedPaths, mergedWatchOptions, (filepath, event)=>{
+        if (filepath.includes('-server-loaders.js')) return void delete require.cache[filepath];
+        watcher.updateDepTree();
+        watcher.cleanDepCache(filepath);
+        onServerChange({
+            pwd,
+            filepath,
+            event,
+            server
+        });
+    });
+    return watcher;
+}
+export { startWatcher };

package/dist/esm-node/helpers/mock.mjs

@@ -0,0 +1,87 @@
+import "node:module";
+import node_path from "node:path";
+import { AGGRED_DIR } from "@modern-js/server-core";
+import { connectMockMid2HonoMid } from "@modern-js/server-core/node";
+import { fs } from "@modern-js/utils";
+import { match } from "path-to-regexp";
+let mockAPIs = [];
+let mockConfig;
+const parseKey = (key)=>{
+    const _blank = ' ';
+    const splitted = key.split(_blank).filter(Boolean);
+    if (splitted.length > 1) {
+        const [method, pathname] = splitted;
+        return {
+            method: (method ?? 'get').toLowerCase(),
+            path: pathname ?? '/'
+        };
+    }
+    return {
+        method: 'get',
+        path: key
+    };
+};
+const getMockModule = async (pwd)=>{
+    const exts = [
+        '.ts',
+        '.js'
+    ];
+    let mockFilePath = '';
+    for (const ext of exts){
+        const maybeMatch = node_path.join(pwd, `${AGGRED_DIR.mock}/index${ext}`);
+        if (await fs.pathExists(maybeMatch)) {
+            mockFilePath = maybeMatch;
+            break;
+        }
+    }
+    if (!mockFilePath) return;
+    const { default: mockHandlers, config } = await import(mockFilePath);
+    const enable = config?.enable;
+    if (false === enable) return;
+    if (!mockHandlers) throw new Error(`Mock file ${mockFilePath} parsed failed!`);
+    return {
+        mockHandlers,
+        config
+    };
+};
+const getMatched = (request, mockApis)=>{
+    const { path: targetPathname, method: targetMethod } = request;
+    const matched = mockApis.find((mockApi)=>{
+        const { method, path: pathname } = mockApi;
+        if (method.toLowerCase() === targetMethod.toLowerCase()) return match(pathname, {
+            decode: decodeURIComponent
+        })(targetPathname);
+        return false;
+    });
+    return matched;
+};
+async function initOrUpdateMockMiddlewares(pwd) {
+    const mockModule = await getMockModule(pwd);
+    mockConfig = mockModule?.config;
+    mockAPIs = Object.entries(mockModule?.mockHandlers || {}).map(([key, handler])=>{
+        const { method, path } = parseKey(key);
+        return {
+            method,
+            path,
+            handler
+        };
+    });
+}
+async function getMockMiddleware(pwd) {
+    await initOrUpdateMockMiddlewares(pwd);
+    const mockMiddleware = async (c, next)=>{
+        if ('function' == typeof mockConfig?.enable) {
+            const isEnabled = mockConfig.enable(c.env.node.req, c.env.node.res);
+            if (!isEnabled) return next();
+        }
+        const matchedMockAPI = getMatched(c.req, mockAPIs);
+        if (matchedMockAPI) {
+            const { handler } = matchedMockAPI;
+            if ('function' == typeof handler) return await connectMockMid2HonoMid(handler)(c, next);
+            return c.json(handler);
+        }
+        return next();
+    };
+    return mockMiddleware;
+}
+export { getMatched, getMockMiddleware, initOrUpdateMockMiddlewares };

package/dist/esm-node/helpers/repack.mjs

@@ -0,0 +1,18 @@
+import __rslib_shim_module__ from "node:module";
+const require = /*#__PURE__*/ __rslib_shim_module__.createRequire(/*#__PURE__*/ (()=>import.meta.url)());
+import { fileReader } from "@modern-js/runtime-utils/fileReader";
+const cleanSSRCache = (distDir)=>{
+    Object.keys(require.cache).forEach((key)=>{
+        if (key.startsWith(distDir)) delete require.cache[key];
+    });
+};
+const onRepack = (distDir, hooks)=>{
+    cleanSSRCache(distDir);
+    fileReader.reset();
+    hooks.onReset.call({
+        event: {
+            type: 'repack'
+        }
+    });
+};
+export { onRepack };

package/dist/esm-node/helpers/utils.mjs

@@ -0,0 +1,4 @@
+import "node:module";
+import { createDebugger } from "@modern-js/utils";
+const debug = createDebugger('server');
+export { debug };

package/dist/esm-node/index.mjs

@@ -0,0 +1,2 @@
+import "node:module";
+export { createDevServer } from "./createDevServer.mjs";

package/dist/esm-node/types.mjs

@@ -0,0 +1 @@
+import "node:module";

package/dist/types/createDevServer.d.ts

@@ -0,0 +1,8 @@
+import type { ApplyPlugins, ModernDevServerOptions } from './types';
+export declare function createDevServer(options: ModernDevServerOptions, applyPlugins: ApplyPlugins): Promise<{
+    server: (import("node:http").Server<typeof import("node:http").IncomingMessage, typeof import("node:http").ServerResponse> | import("node:https").Server<typeof import("node:http").IncomingMessage, typeof import("node:http").ServerResponse> | import("node:http2").Http2SecureServer<typeof import("node:http").IncomingMessage, typeof import("node:http").ServerResponse, typeof import("node:http2").Http2ServerRequest, typeof import("node:http2").Http2ServerResponse>) & {
+        getRequestListener: () => ReturnType<(handler: import("@modern-js/server-core/dist/types/types").RequestHandler) => (req: import("@modern-js/types/server").NodeRequest, res: import("@modern-js/types/server").NodeResponse) => Promise<void>>;
+        getRequestHandler: () => import("@modern-js/server-core/dist/types/types").RequestHandler;
+    };
+    afterListen: () => Promise<void>;
+}>;

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

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

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

@@ -0,0 +1,28 @@
+export declare const defaultIgnores: string[];
+export interface DependencyTreeOptions {
+    root: string;
+    ignore?: string[];
+}
+export interface TreeNode {
+    module: NodeModule;
+    parent: Set<TreeNode>;
+    children: Set<TreeNode>;
+}
+/**
+ * `require.cache` already is a dependency tree, however require cache's
+ * `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;
+    constructor();
+    getNode(path: string): TreeNode | undefined;
+    /**
+     * update dependency tree
+     *
+     * @param cache
+     */
+    update(cache: any): void;
+    private shouldIgnore;
+}

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

@@ -0,0 +1,17 @@
+import { type FSWatcher, type WatchOptions } from '@modern-js/utils';
+export type WatchEvent = 'add' | 'change' | 'unlink';
+export declare const defaultWatchOptions: {
+    ignoreInitial: boolean;
+    ignored: RegExp;
+};
+export declare const getWatchedFiles: (watcher: FSWatcher) => string[];
+export declare const mergeWatchOptions: (options?: WatchOptions) => WatchOptions;
+export default class Watcher {
+    private dependencyTree;
+    private watcher;
+    listen(files: string[], options: WatchOptions, callback: (changed: string, event: WatchEvent) => void): void;
+    createDepTree(): void;
+    updateDepTree(): void;
+    cleanDepCache(filepath: string): void;
+    close(): Promise<void>;
+}

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

@@ -0,0 +1,10 @@
+export declare class StatsCache {
+    private readonly cachedHash;
+    private readonly cachedSize;
+    add(files: string[]): void;
+    refresh(filename: string): void;
+    del(filename: string): void;
+    isDiff(filename: string): boolean;
+    has(filename: string): boolean;
+    private hash;
+}

package/dist/types/dev.d.ts

@@ -0,0 +1,9 @@
+import type { BuilderInstance, Rspack } from '@modern-js/builder';
+import type { ServerBaseOptions, ServerPlugin } from '@modern-js/server-core';
+import type { ModernDevServerOptions } from './types';
+type BuilderDevServer = Awaited<ReturnType<BuilderInstance['createDevServer']>>;
+export type DevPluginOptions = ModernDevServerOptions<ServerBaseOptions> & {
+    builderDevServer?: BuilderDevServer;
+};
+export declare const devPlugin: (options: DevPluginOptions, compiler: Rspack.Compiler | Rspack.MultiCompiler | null) => ServerPlugin;
+export {};

package/dist/types/helpers/devOptions.d.ts

@@ -0,0 +1,11 @@
+import type { BuilderInstance } from '@modern-js/builder';
+import type { DevServerOptions } from '../types';
+export declare const getDevOptions: (devOptions: DevServerOptions) => {
+    setupMiddlewares?: Array<(middlewares: {
+        unshift: (...handlers: import("@modern-js/types/server").RequestHandler[]) => void;
+        push: (...handlers: import("@modern-js/types/server").RequestHandler[]) => void;
+    }, server: import("@modern-js/types/server").ExposeServerApis) => void>;
+    https?: import("@modern-js/types/server/devServer").DevServerHttpsOptions;
+    server?: import("../types").DevServerConfig;
+};
+export declare const getDevAssetPrefix: (builder?: BuilderInstance) => Promise<string>;

package/dist/types/helpers/fileReader.d.ts

@@ -0,0 +1,3 @@
+import type { Rspack } from '@modern-js/builder';
+import type { Middleware } from '@modern-js/server-core';
+export declare const initFileReader: (compiler: Rspack.Compiler | Rspack.MultiCompiler | null) => Middleware;

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

@@ -0,0 +1,15 @@
+import { type ServerBase } from '@modern-js/server-core';
+import { type WatchOptions } from '@modern-js/utils';
+import Watcher from '../dev-tools/watcher';
+export * from './devOptions';
+export * from './fileReader';
+export * from './mock';
+export * from './repack';
+export declare function startWatcher({ pwd, distDir, apiDir, sharedDir, watchOptions, server, }: {
+    pwd: string;
+    distDir: string;
+    apiDir: string;
+    sharedDir: string;
+    watchOptions?: WatchOptions;
+    server: ServerBase;
+}): Watcher;

package/dist/types/helpers/mock.d.ts

@@ -0,0 +1,16 @@
+import { type InternalRequest, type Middleware } from '@modern-js/server-core';
+import type { NextFunction } from '@modern-js/types';
+import type { NodeRequest, NodeResponse } from '@modern-js/types/server';
+/** Types: Mock  */
+type MockHandler = {
+    data: any;
+} | ((req: NodeRequest, res: NodeResponse, next: NextFunction) => Promise<void> | void);
+type MockAPI = {
+    method: string;
+    path: string;
+    handler: MockHandler;
+};
+export declare const getMatched: (request: InternalRequest, mockApis: MockAPI[]) => MockAPI | undefined;
+export declare function initOrUpdateMockMiddlewares(pwd: string): Promise<void>;
+export declare function getMockMiddleware(pwd: string): Promise<Middleware>;
+export {};

package/dist/types/helpers/repack.d.ts

@@ -0,0 +1,2 @@
+import type { ServerPluginHooks } from '@modern-js/server-core';
+export declare const onRepack: (distDir: string, hooks: ServerPluginHooks) => void;

package/dist/types/helpers/utils.d.ts

@@ -0,0 +1 @@
+export declare const debug: import("@modern-js/utils/compiled/debug").Debugger;

package/dist/types/index.d.ts

@@ -0,0 +1,4 @@
+import type { DevServerOptions } from './types';
+export { createDevServer } from './createDevServer';
+export type { ApplyPlugins, CorsOptions, ModernDevServerOptions, } from './types';
+export type SetupMiddlewares = DevServerOptions['setupMiddlewares'];

package/dist/types/types.d.ts

@@ -0,0 +1,56 @@
+import type { Server as NodeServer } from 'node:http';
+import type { Http2SecureServer } from 'node:http2';
+import type { BuilderInstance } from '@modern-js/builder';
+import type { ServerBase, ServerBaseOptions, ServerPlugin } from '@modern-js/server-core';
+import type { DevServerHttpsOptions, ExposeServerApis, RequestHandler } from '@modern-js/types';
+export type { DevServerHttpsOptions };
+type StaticOrigin = boolean | string | RegExp | Array<boolean | string | RegExp>;
+type CustomOrigin = (requestOrigin: string | undefined, callback: (err: Error | null, origin?: StaticOrigin) => void) => void;
+export interface CorsOptions {
+    /**
+     * @default '*''
+     */
+    origin?: StaticOrigin | CustomOrigin | undefined;
+}
+export interface DevServerConfig {
+    /**
+     * Configure CORS for the dev server.
+     * - object: enable CORS with the specified options.
+     * - true: enable CORS with default options (allow all origins, not recommended).
+     * - false: disable CORS.
+     * @default
+     * ```js
+     * { origin: defaultAllowedOrigins }
+     * ```
+     * where `defaultAllowedOrigins` includes:
+     * - `localhost`
+     * - `127.0.0.1`
+     *
+     * @link https://github.com/expressjs/cors
+     */
+    cors?: boolean | CorsOptions;
+}
+export type DevServerOptions = {
+    /** Provides the ability to execute a custom function and apply custom middlewares */
+    setupMiddlewares?: Array<(
+    /** Order: `devServer.before` => `unshift` => internal middlewares => `push` => `devServer.after` */
+    middlewares: {
+        /** Use the `unshift` method if you want to run a middleware before all other middlewares */
+        unshift: (...handlers: RequestHandler[]) => void;
+        /** Use the `push` method if you want to run a middleware after all other middlewares */
+        push: (...handlers: RequestHandler[]) => void;
+    }, server: ExposeServerApis) => void>;
+    /** Whether to enable hot reload. */
+    https?: DevServerHttpsOptions;
+    /** Dev server specific options. */
+    server?: DevServerConfig;
+};
+export type ExtraOptions = {
+    dev: DevServerOptions;
+    runCompile?: boolean;
+    serverConfigPath: string;
+    builder?: BuilderInstance;
+    plugins?: ServerPlugin[];
+};
+export type ModernDevServerOptions<O extends ServerBaseOptions = ServerBaseOptions> = O & ExtraOptions;
+export type ApplyPlugins<O extends ServerBaseOptions = ServerBaseOptions> = (server: ServerBase, options: ModernDevServerOptions<O>, nodeServer?: NodeServer | Http2SecureServer) => Promise<void>;