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

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021-present Modern.js
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,26 @@
+<p align="center">
+  <a href="https://modernjs.dev" target="blank"><img src="https://lf3-static.bytednsdoc.com/obj/eden-cn/ylaelkeh7nuhfnuhf/modernjs-cover.png" width="300" alt="Modern.js Logo" /></a>
+</p>
+
+<h1 align="center">Modern.js</h1>
+
+<p align="center">
+  A Progressive React Framework for modern web development.
+</p>
+
+## Getting Started
+
+Please follow [Quick Start](https://modernjs.dev/en/guides/get-started/quick-start) to get started with Modern.js.
+
+## Documentation
+
+- [English Documentation](https://modernjs.dev/en/)
+- [中文文档](https://modernjs.dev)
+
+## Contributing
+
+Please read the [Contributing Guide](https://github.com/web-infra-dev/modern.js/blob/main/CONTRIBUTING.md).
+
+## License
+
+Modern.js is [MIT licensed](https://github.com/web-infra-dev/modern.js/blob/main/LICENSE).

package/dist/cjs/createDevServer.js

@@ -0,0 +1,102 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    createDevServer: ()=>createDevServer
+});
+const external_node_path_namespaceObject = require("node:path");
+var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
+const server_core_namespaceObject = require("@modern-js/server-core");
+const node_namespaceObject = require("@modern-js/server-core/node");
+const external_dev_js_namespaceObject = require("./dev.js");
+const index_js_namespaceObject = require("./helpers/index.js");
+async function createDevServer(options, applyPlugins) {
+    const { config, pwd, serverConfigPath, builder } = options;
+    const dev = (0, index_js_namespaceObject.getDevOptions)(options.dev);
+    const distDir = external_node_path_default().resolve(pwd, config.output.distPath?.root || 'dist');
+    const serverConfig = await (0, node_namespaceObject.loadServerRuntimeConfig)(serverConfigPath) || {};
+    const prodServerOptions = {
+        ...options,
+        pwd: distDir,
+        serverConfig: {
+            ...serverConfig,
+            ...options.serverConfig
+        },
+        plugins: [
+            ...serverConfig.plugins || [],
+            ...options.plugins || []
+        ]
+    };
+    const server = (0, server_core_namespaceObject.createServerBase)(prodServerOptions);
+    const devHttpsOption = 'object' == typeof dev && dev.https;
+    const isHttp2 = !!devHttpsOption;
+    let nodeServer;
+    if (devHttpsOption) {
+        const { genHttpsOptions } = await import("./dev-tools/https/index.js");
+        const httpsOptions = await genHttpsOptions(devHttpsOption, pwd);
+        nodeServer = await (0, node_namespaceObject.createNodeServer)(server.handle.bind(server), httpsOptions, isHttp2);
+    } else nodeServer = await (0, node_namespaceObject.createNodeServer)(server.handle.bind(server));
+    const promise = (0, index_js_namespaceObject.getDevAssetPrefix)(builder);
+    let compiler = null;
+    builder?.onAfterCreateCompiler((context)=>{
+        compiler = context.compiler;
+    });
+    const builderDevServer = await builder?.createDevServer({
+        runCompile: options.runCompile
+    });
+    server.addPlugins([
+        (0, external_dev_js_namespaceObject.devPlugin)({
+            ...options,
+            builderDevServer
+        }, compiler)
+    ]);
+    const assetPrefix = await promise;
+    if (assetPrefix) prodServerOptions.config.output.assetPrefix = assetPrefix;
+    await applyPlugins(server, prodServerOptions, nodeServer);
+    await server.init();
+    const afterListen = async ()=>{
+        await builderDevServer?.afterListen();
+    };
+    return {
+        server: nodeServer,
+        afterListen
+    };
+}
+exports.createDevServer = __webpack_exports__.createDevServer;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createDevServer"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

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

@@ -0,0 +1,57 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    genHttpsOptions: ()=>genHttpsOptions
+});
+const utils_namespaceObject = require("@modern-js/utils");
+const genHttpsOptions = async (userOptions, pwd)=>{
+    const httpsOptions = 'boolean' == typeof userOptions ? {} : userOptions;
+    if (!httpsOptions.key || !httpsOptions.cert) {
+        let devcertPath;
+        try {
+            devcertPath = (0, utils_namespaceObject.tryResolve)('devcert', pwd, __dirname);
+        } catch (err) {
+            const packageManager = await (0, utils_namespaceObject.getPackageManager)(pwd);
+            const command = utils_namespaceObject.chalk.yellow.bold(`${packageManager} add devcert@1.2.2 -D`);
+            utils_namespaceObject.logger.error('You have enabled "dev.https" option, but the "devcert" package is not installed.');
+            utils_namespaceObject.logger.error(`Please run ${command} to install manually, otherwise the https can not work.`);
+            throw new Error('[https] "devcert" is not found.');
+        }
+        const devcert = require(devcertPath);
+        const selfsign = await devcert.certificateFor([
+            'localhost'
+        ]);
+        return selfsign;
+    }
+    return httpsOptions;
+};
+exports.genHttpsOptions = __webpack_exports__.genHttpsOptions;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "genHttpsOptions"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/dev-tools/watcher/dependencyTree.js

@@ -0,0 +1,94 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    DependencyTree: ()=>DependencyTree,
+    defaultIgnores: ()=>defaultIgnores
+});
+const external_minimatch_namespaceObject = require("minimatch");
+const defaultIgnores = [
+    '**/coverage/**',
+    '**/node_modules/**',
+    '**/.*/**',
+    '**/*.d.ts',
+    '**/*.log'
+];
+class DependencyTree {
+    getNode(path) {
+        return this.tree.get(path);
+    }
+    update(cache) {
+        this.tree.clear();
+        Object.keys(cache).forEach((path)=>{
+            if (!this.shouldIgnore(path)) {
+                const module = cache[path];
+                this.tree.set(module.filename, {
+                    module,
+                    parent: new Set(),
+                    children: new Set()
+                });
+            }
+        });
+        for (const treeNode of this.tree.values()){
+            const { parent } = treeNode.module;
+            const { children } = treeNode.module;
+            if (parent && !this.shouldIgnore(parent.filename)) {
+                const parentTreeNode = this.tree.get(parent.filename);
+                if (parentTreeNode) treeNode.parent.add(parentTreeNode);
+            }
+            children?.forEach((child)=>{
+                if (!this.shouldIgnore(child.filename)) {
+                    const childTreeNode = this.tree.get(child.filename);
+                    if (childTreeNode) {
+                        treeNode.children.add(childTreeNode);
+                        childTreeNode.parent.add(treeNode);
+                    }
+                }
+            });
+        }
+    }
+    shouldIgnore(path) {
+        return !path || Boolean(this.ignore.find((rule)=>external_minimatch_namespaceObject.match([
+                path
+            ], rule, {
+                dot: true
+            }).length > 0));
+    }
+    constructor(){
+        this.tree = new Map();
+        this.ignore = [
+            ...defaultIgnores
+        ];
+    }
+}
+exports.DependencyTree = __webpack_exports__.DependencyTree;
+exports.defaultIgnores = __webpack_exports__.defaultIgnores;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "DependencyTree",
+    "defaultIgnores"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/dev-tools/watcher/index.js

@@ -0,0 +1,143 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    default: ()=>Watcher,
+    defaultWatchOptions: ()=>defaultWatchOptions,
+    getWatchedFiles: ()=>getWatchedFiles,
+    mergeWatchOptions: ()=>mergeWatchOptions
+});
+const utils_namespaceObject = require("@modern-js/utils");
+const external_path_namespaceObject = require("path");
+var external_path_default = /*#__PURE__*/ __webpack_require__.n(external_path_namespaceObject);
+const external_dependencyTree_js_namespaceObject = require("./dependencyTree.js");
+const external_statsCache_js_namespaceObject = require("./statsCache.js");
+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(external_path_default().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 external_statsCache_js_namespaceObject.StatsCache();
+        const watcher = utils_namespaceObject.chokidar.watch(filenames, options);
+        watcher.on('ready', ()=>{
+            cache.add(getWatchedFiles(watcher));
+        });
+        watcher.on('change', (changed)=>{
+            if (!utils_namespaceObject.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 external_dependencyTree_js_namespaceObject.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;
+    }
+}
+exports["default"] = __webpack_exports__["default"];
+exports.defaultWatchOptions = __webpack_exports__.defaultWatchOptions;
+exports.getWatchedFiles = __webpack_exports__.getWatchedFiles;
+exports.mergeWatchOptions = __webpack_exports__.mergeWatchOptions;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "default",
+    "defaultWatchOptions",
+    "getWatchedFiles",
+    "mergeWatchOptions"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/dev-tools/watcher/statsCache.js

@@ -0,0 +1,95 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    StatsCache: ()=>StatsCache
+});
+const external_crypto_namespaceObject = require("crypto");
+var external_crypto_default = /*#__PURE__*/ __webpack_require__.n(external_crypto_namespaceObject);
+const external_fs_namespaceObject = require("fs");
+var external_fs_default = /*#__PURE__*/ __webpack_require__.n(external_fs_namespaceObject);
+class StatsCache {
+    add(files) {
+        const { cachedHash, cachedSize } = this;
+        for (const filename of files)if (external_fs_default().existsSync(filename)) {
+            const stats = external_fs_default().statSync(filename);
+            if (stats.isFile() && !cachedHash[filename]) {
+                cachedHash[filename] = this.hash(stats, filename);
+                cachedSize[filename] = stats.size;
+            }
+        }
+    }
+    refresh(filename) {
+        const { cachedHash, cachedSize } = this;
+        if (external_fs_default().existsSync(filename)) {
+            const stats = external_fs_default().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 = external_fs_default().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 external_crypto_default().createHash('md5').update(external_fs_default().readFileSync(filename)).digest('hex');
+    }
+    constructor(){
+        this.cachedHash = {};
+        this.cachedSize = {};
+    }
+}
+exports.StatsCache = __webpack_exports__.StatsCache;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "StatsCache"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/dev.js

@@ -0,0 +1,111 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    devPlugin: ()=>devPlugin
+});
+const node_namespaceObject = require("@modern-js/server-core/node");
+const utils_namespaceObject = require("@modern-js/utils");
+const index_js_namespaceObject = require("./helpers/index.js");
+const devPlugin = (options, compiler)=>({
+        name: '@modern-js/plugin-dev',
+        setup (api) {
+            const { config, pwd, builder, builderDevServer } = options;
+            const closeCb = [];
+            const dev = (0, index_js_namespaceObject.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) (0, index_js_namespaceObject.onRepack)(distDirectory, hooks);
+                });
+                const { watchOptions } = config.server;
+                const watcher = (0, index_js_namespaceObject.startWatcher)({
+                    pwd,
+                    distDir: distDirectory,
+                    apiDir: apiDirectory || utils_namespaceObject.API_DIR,
+                    sharedDir: sharedDirectory || utils_namespaceObject.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: (0, node_namespaceObject.connectMid2HonoMid)(middleware)
+                    });
+                });
+                const mockMiddleware = await (0, index_js_namespaceObject.getMockMiddleware)(pwd);
+                middlewares.push({
+                    name: 'mock-dev',
+                    handler: mockMiddleware
+                });
+                builderMiddlewares && middlewares.push({
+                    name: 'rsbuild-dev',
+                    handler: (0, node_namespaceObject.connectMid2HonoMid)(builderMiddlewares)
+                });
+                after.forEach((middleware, index)=>{
+                    middlewares.push({
+                        name: `after-dev-server-${index}`,
+                        handler: (0, node_namespaceObject.connectMid2HonoMid)(middleware)
+                    });
+                });
+                middlewares.push({
+                    name: 'init-file-reader',
+                    handler: (0, index_js_namespaceObject.initFileReader)(compiler)
+                });
+            });
+        }
+    });
+exports.devPlugin = __webpack_exports__.devPlugin;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "devPlugin"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});