warehouse-mock 1.1.5 → 1.2.0

package/README.md

@@ -2,13 +2,16 @@
 
 <div align="center">
 
-极简 Vue Mock 插件，零业务代码侵入，完美支持 RPC 风格接口
+极简 Vue Mock 插件（**Webpack / Vue CLI** 版），零业务代码侵入，完美支持 RPC 风格接口
 
 [![npm version](https://img.shields.io/npm/v/warehouse-mock.svg)](https://www.npmjs.com/package/warehouse-mock)
 [![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](https://opensource.org/licenses/MIT)
 
 </div>
 
+> 本包是 Warehouse Mock 的 **Webpack 适配**，核心逻辑由 [`warehouse-mock-core`](https://www.npmjs.com/package/warehouse-mock-core) 提供（会作为依赖自动安装）。
+> Vue 3 + Vite 项目请使用 [`warehouse-mock-vite`](https://www.npmjs.com/package/warehouse-mock-vite)，二者数据格式与功能完全一致。
+
 ## 安装
 
 ```bash
@@ -19,20 +22,58 @@ npm install warehouse-mock --save-dev
 
 ### 1. 配置 vue.config.js
 
+**Vue CLI 5（Webpack 5）：**
+
 ```javascript
 const WarehouseMockPlugin = require('warehouse-mock');
 
 const isMock = process.env.MOCK === 'true';
+const mockPlugin = isMock ? new WarehouseMockPlugin() : null;
 
 module.exports = {
   configureWebpack: config => {
-    if (isMock) {
-      config.plugins.push(new WarehouseMockPlugin());
+    if (isMock && mockPlugin) {
+      config.plugins.push(mockPlugin);
+    }
+  },
+  devServer: {
+    // Webpack 5 通过 setupMiddlewares 挂载拦截中间件
+    setupMiddlewares: (middlewares, devServer) => {
+      if (isMock && mockPlugin) {
+        return mockPlugin.setupMiddlewares(middlewares, devServer);
+      }
+      return middlewares;
     }
   }
 };
 ```
 
+**Vue CLI 3-4（Webpack 4）：** 用 `before` 钩子挂载，并手动注入环境变量：
+
+```javascript
+const WarehouseMockPlugin = require('warehouse-mock');
+const webpack = require('webpack');
+
+const isMock = process.env.MOCK === 'true';
+const mockPlugin = isMock ? new WarehouseMockPlugin() : null;
+
+module.exports = {
+  configureWebpack: config => {
+    if (isMock && mockPlugin) {
+      config.plugins.push(
+        new webpack.DefinePlugin({
+          'process.env.VUE_APP_MOCK': JSON.stringify('true'),
+        })
+      );
+      config.plugins.push(mockPlugin);
+    }
+  },
+  devServer: {
+    before: isMock && mockPlugin ? app => mockPlugin.runBefore(app) : undefined,
+  }
+};
+```
+
 ### 2. 添加 Mock 脚本
 
 ```json
@@ -57,12 +98,16 @@ if (process.env.VUE_APP_MOCK === 'true') {
 
 ### 4. 创建 Mock 数据
 
-在项目根目录创建 `warehouseMock/` 文件夹，添加 JSON 文件：
+在项目根目录创建 `warehouseMock/` 文件夹，每个接口对应一个目录（详见下方 [Mock 文件命名规则](#mock-文件命名规则)）：
 
 ```
 warehouseMock/
-├── user.account.getInfo.json
-└── user.taurus.pointInfo.json
+├── user.account.getInfo/
+│   ├── .config.json
+│   └── default.json
+└── user.taurus.pointInfo/
+    ├── .config.json
+    └── default.json
 ```
 
 ### 5. 启动
@@ -98,6 +143,12 @@ interface MockPluginOptions {
     target: string;
     changeOrigin?: boolean;
   };
+
+  // 管理后台配置
+  admin?: {
+    enabled?: boolean;  // 是否启用，默认 true
+    port?: number;      // 端口，默认 3100
+  };
 }
 ```
 
@@ -135,19 +186,44 @@ new WarehouseMockPlugin({
 
 ## Mock 文件命名规则
 
-### RPC 风格 (推荐)
+接口名对应 `warehouseMock/` 下的一个**目录**（推荐，支持多场景），目录内含 `.config.json` 配置和若干场景文件：
+
+```
+warehouseMock/
+└── user.account.getInfo/        # 接口目录（接口名）
+    ├── .config.json             # { name, delay, enabled, activeScene }
+    ├── default.json             # 默认场景数据
+    └── success.json             # 其他场景数据
+```
+
+`.config.json`：
+
+```json
+{
+  "name": "user.account.getInfo",
+  "delay": 0,
+  "enabled": true,
+  "activeScene": "default"
+}
+```
+
+> 也兼容旧的单文件格式 `warehouseMock/user.account.getInfo.json`。
 
-| 请求 URL | Mock 文件名 |
+### 接口名与请求 URL 的对应
+
+**RPC 风格 (推荐)**
+
+| 请求 URL | 接口目录 |
 |---------|-----------|
-| `GET /api?user.account.getInfo` | `user.account.getInfo.json` |
-| `POST /mock-api?user.taurus.pointInfo` | `user.taurus.pointInfo.json` |
+| `GET /api?user.account.getInfo` | `warehouseMock/user.account.getInfo/` |
+| `POST /mock-api?user.taurus.pointInfo` | `warehouseMock/user.taurus.pointInfo/` |
 
-### RESTful 风格
+**RESTful 风格**
 
-| 请求 URL | Mock 文件名 |
+| 请求 URL | 接口目录 / 文件 |
 |---------|-----------|
-| `GET /api/user/info` | `api_user_info.json` (扁平化) |
-| `GET /api/user/info` | `api/user/info.json` (嵌套) |
+| `GET /api/user/info` | `warehouseMock/api_user_info/`（扁平化） |
+| `GET /api/user/info` | `warehouseMock/api/user/info.json`（嵌套） |
 
 ## 调试工具
 
@@ -161,15 +237,23 @@ new WarehouseMockPlugin({
 
 ## 核心特性
 
-- ✅ **极简配置** - vue.config.js 只需 3 行代码
+- ✅ **极简配置** - vue.config.js 几行代码即可接入
 - ✅ **零业务侵入** - 无需修改接口调用代码
 - ✅ **RPC 风格支持** - 原生支持 RPC 接口
+- ✅ **多场景** - 每个接口可配置多个场景，一键切换
 - ✅ **实时热更新** - 修改 Mock 数据，刷新即可
 - ✅ **按需拦截** - 只拦截配置了 Mock 文件的接口
 - ✅ **代理模式** - 未匹配请求转发到真实 API
 - ✅ **自动注入环境变量** - 无需手动配置 DefinePlugin
+- ✅ **可视化管理后台** - 内置 Web 界面管理 Mock（可选）
 - ✅ **兼容性强** - 支持 Webpack 4/5，Vue CLI 3/4/5
 
+## 相关包
+
+- [`warehouse-mock-vite`](https://www.npmjs.com/package/warehouse-mock-vite) - Vue 3 + Vite 版本
+- [`warehouse-mock-core`](https://www.npmjs.com/package/warehouse-mock-core) - 框架无关核心引擎
+- [`warehouse-mock-admin`](https://www.npmjs.com/package/warehouse-mock-admin) - 可视化管理后台
+
 ## License
 
 MIT

package/dist/index.d.ts

@@ -1,31 +1,15 @@
 import { Compiler } from 'webpack';
-interface MockPluginOptions {
-    mockPath?: string;
-    apiPrefixes?: string[];
-    localApiPrefix?: string;
-    enabled?: boolean;
-    proxy?: {
-        target: string;
-        changeOrigin?: boolean;
-    };
+import { MockEngineOptions } from 'warehouse-mock-core';
+interface MockPluginOptions extends MockEngineOptions {
     injectEnv?: boolean;
-    delay?: number;
-    admin?: {
-        enabled?: boolean;
-        port?: number;
-    };
 }
 declare class WarehouseMockPlugin {
-    private options;
-    private resolvedMockPath;
+    private engine;
+    private injectEnv;
     private isEnabled;
-    private adminServer;
     constructor(options?: MockPluginOptions);
     /**
      * 实时扫描 mock 目录，获取所有 mock 文件名列表
-     * 支持两种格式：
-     * 1. 旧格式：api.json
-     * 2. 新格式：api/.config.json
      */
     getMockFileList(): string[];
     /**
@@ -33,10 +17,6 @@ declare class WarehouseMockPlugin {
      */
     getLocalApiPrefix(): string;
     apply(compiler: Compiler): void;
-    /**
-     * 启动管理后台服务
-     */
-    private startAdminServer;
     /**
      * 自动注入环境变量 VUE_APP_MOCK
      */
@@ -49,14 +29,5 @@ declare class WarehouseMockPlugin {
      * 公共方法：设置中间件 (Webpack 4 / Vue CLI 3-4)
      */
     runBefore(app: any, server?: any, compiler?: any, originalBefore?: Function): void;
-    private getResolvedMockPath;
-    private ensureMockDirectory;
-    private createDemoFile;
-    private readInterfaceConfig;
-    private handleRequest;
-    /**
-     * 代理请求到真实 API（改进版）
-     */
-    private proxyRequest;
 }
 export = WarehouseMockPlugin;

package/dist/index.js

@@ -2,71 +2,25 @@
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
-const fs_1 = __importDefault(require("fs"));
-const path_1 = __importDefault(require("path"));
 const chalk_1 = __importDefault(require("chalk"));
+const warehouse_mock_core_1 = require("warehouse-mock-core");
 class WarehouseMockPlugin {
     constructor(options = {}) {
-        var _a, _b;
-        this.resolvedMockPath = '';
-        this.isEnabled = true;
-        this.adminServer = null;
-        // 默认配置
-        this.options = {
-            mockPath: options.mockPath || 'warehouseMock',
-            apiPrefixes: options.apiPrefixes || ['/api', '/mock-api'],
-            localApiPrefix: options.localApiPrefix || '/mock-api',
-            enabled: options.enabled !== undefined ? options.enabled : true,
-            proxy: options.proxy || undefined,
-            injectEnv: options.injectEnv !== undefined ? options.injectEnv : true,
-            delay: options.delay || 0,
-            admin: {
-                enabled: ((_a = options.admin) === null || _a === void 0 ? void 0 : _a.enabled) !== undefined ? options.admin.enabled : true,
-                port: ((_b = options.admin) === null || _b === void 0 ? void 0 : _b.port) || 3100,
-            },
-        };
-        // 判断是否启用（支持环境变量控制）
-        if (process.env.MOCK === 'false' || process.env.VUE_APP_MOCK === 'false') {
-            this.isEnabled = false;
-        }
-        if (this.options.enabled === false) {
-            this.isEnabled = false;
-        }
+        this.injectEnv = options.injectEnv !== undefined ? options.injectEnv : true;
+        this.engine = new warehouse_mock_core_1.MockEngine(options);
+        this.isEnabled = this.engine.isEnabled;
     }
     /**
      * 实时扫描 mock 目录，获取所有 mock 文件名列表
-     * 支持两种格式：
-     * 1. 旧格式：api.json
-     * 2. 新格式：api/.config.json
      */
     getMockFileList() {
-        const mockPath = this.getResolvedMockPath();
-        const fileList = [];
-        if (fs_1.default.existsSync(mockPath)) {
-            const files = fs_1.default.readdirSync(mockPath);
-            files.forEach((file) => {
-                const filePath = path_1.default.join(mockPath, file);
-                const stats = fs_1.default.statSync(filePath);
-                if (stats.isDirectory()) {
-                    // 新格式：检查目录下是否有 .config.json
-                    const configPath = path_1.default.join(filePath, '.config.json');
-                    if (fs_1.default.existsSync(configPath)) {
-                        fileList.push(file);
-                    }
-                }
-                else if (file.endsWith('.json') && !file.startsWith('.')) {
-                    // 旧格式：直接是 .json 文件（排除 .config.json 等隐藏文件）
-                    fileList.push(file.replace(/\.json$/, ''));
-                }
-            });
-        }
-        return fileList;
+        return this.engine.getMockFileList();
     }
     /**
      * 获取本地代理路径前缀
      */
     getLocalApiPrefix() {
-        return this.options.localApiPrefix || '/mock-api';
+        return this.engine.getLocalApiPrefix();
     }
     apply(compiler) {
         // 如果未启用，直接返回
@@ -74,79 +28,18 @@ class WarehouseMockPlugin {
             console.log(chalk_1.default.yellow('[WarehouseMock] Mock 模式未启用'));
             return;
         }
-        this.resolvedMockPath = path_1.default.resolve(compiler.context, this.options.mockPath);
+        // 解析 mock 目录（基于 webpack 上下文）
+        this.engine.resolveMockPath(compiler.context);
         // 自动注入环境变量 VUE_APP_MOCK
-        if (this.options.injectEnv) {
+        if (this.injectEnv) {
             this.injectEnvironmentVariable(compiler);
         }
-        // 确保 mock 目录存在
-        if (!fs_1.default.existsSync(this.resolvedMockPath)) {
-            try {
-                fs_1.default.mkdirSync(this.resolvedMockPath, { recursive: true });
-                console.log(chalk_1.default.green(`[WarehouseMock] Mock 目录已创建: ${this.resolvedMockPath}`));
-                this.createDemoFile(this.resolvedMockPath);
-            }
-            catch (err) {
-                console.error(chalk_1.default.red(`[WarehouseMock] 创建 Mock 目录失败: ${err}`));
-            }
-        }
-        const mockFileList = this.getMockFileList();
-        console.log(chalk_1.default.cyan(`[WarehouseMock] 已加载 ${mockFileList.length} 个 mock 文件`));
-        if (mockFileList.length > 0) {
-            console.log(chalk_1.default.gray(`  → ${mockFileList.join(', ')}`));
-        }
-        if (this.options.proxy) {
-            console.log(chalk_1.default.cyan(`[WarehouseMock] 代理模式: 未匹配请求 → ${this.options.proxy.target}`));
-        }
-        // 启动管理后台
-        if (this.options.admin && this.options.admin.enabled) {
-            this.startAdminServer();
-        }
+        // 启动引擎：确保目录、打印加载信息、启动管理后台
+        this.engine.start();
         // 注意：devServer 的配置需要在 vue.config.js 中手动配置
         // 对于 Webpack 5 使用 setupMiddlewares
         // 对于 Webpack 4 使用 before
     }
-    /**
-     * 启动管理后台服务
-     */
-    startAdminServer() {
-        var _a;
-        try {
-            // 动态导入管理后台服务
-            let createAdminServer;
-            try {
-                // 尝试导入已安装的包
-                createAdminServer = require('warehouse-mock-admin').createAdminServer;
-            }
-            catch (e) {
-                // 如果找不到，尝试相对路径（开发环境）
-                const adminPath = require('path').resolve(__dirname, '../../mock-admin/dist/server/index.js');
-                createAdminServer = require(adminPath).createAdminServer;
-            }
-            if (!createAdminServer) {
-                throw new Error('无法加载管理后台模块');
-            }
-            const adminResult = createAdminServer({
-                mockPath: this.resolvedMockPath,
-                port: ((_a = this.options.admin) === null || _a === void 0 ? void 0 : _a.port) || 3100,
-            });
-            this.adminServer = adminResult;
-            console.log(chalk_1.default.green(`\n╭────────────────────────────────────────────────────╮`));
-            console.log(chalk_1.default.green(`│  🎨 Mock 数据管理后台已启动                          │`));
-            console.log(chalk_1.default.green(`│                                                    │`));
-            console.log(chalk_1.default.green(`│  ➜  访问地址: ${chalk_1.default.cyan(adminResult.url).padEnd(31)} │`));
-            console.log(chalk_1.default.green(`│                                                    │`));
-            console.log(chalk_1.default.green(`│  在浏览器中打开上面的地址来管理 Mock 数据            │`));
-            console.log(chalk_1.default.green(`╰────────────────────────────────────────────────────╯\n`));
-        }
-        catch (err) {
-            console.log(chalk_1.default.yellow('[WarehouseMock] 管理后台包未安装或加载失败，跳过启动'));
-            console.log(chalk_1.default.gray('  提示：运行 npm install warehouse-mock-admin 来安装管理后台'));
-            if (err.message && !err.message.includes('Cannot find module')) {
-                console.log(chalk_1.default.gray(`  错误详情: ${err.message}`));
-            }
-        }
-    }
     /**
      * 自动注入环境变量 VUE_APP_MOCK
      */
@@ -187,11 +80,10 @@ class WarehouseMockPlugin {
      */
     setupMiddlewares(middlewares, devServer, originalSetupMiddlewares) {
         console.log(chalk_1.default.cyan('[WarehouseMock] Mock 服务已启动'));
-        const mockPath = this.getResolvedMockPath();
-        this.ensureMockDirectory(mockPath);
+        this.engine.ensureMockDirectory();
         middlewares.unshift({
             name: 'warehouse-mock',
-            middleware: (req, res, next) => this.handleRequest(req, res, next, mockPath),
+            middleware: this.engine.middleware,
         });
         if (originalSetupMiddlewares) {
             return originalSetupMiddlewares(middlewares, devServer);
@@ -203,403 +95,11 @@ class WarehouseMockPlugin {
      */
     runBefore(app, server, compiler, originalBefore) {
         console.log(chalk_1.default.cyan('[WarehouseMock] Mock 服务已启动 (before hook)'));
-        const mockPath = this.getResolvedMockPath();
-        this.ensureMockDirectory(mockPath);
-        app.use((req, res, next) => this.handleRequest(req, res, next, mockPath));
+        this.engine.ensureMockDirectory();
+        app.use(this.engine.middleware);
         if (originalBefore) {
             originalBefore(app, server, compiler);
         }
     }
-    getResolvedMockPath() {
-        if (this.resolvedMockPath) {
-            return this.resolvedMockPath;
-        }
-        return path_1.default.isAbsolute(this.options.mockPath)
-            ? this.options.mockPath
-            : path_1.default.resolve(process.cwd(), this.options.mockPath);
-    }
-    ensureMockDirectory(mockPath) {
-        if (!fs_1.default.existsSync(mockPath)) {
-            try {
-                fs_1.default.mkdirSync(mockPath, { recursive: true });
-                console.log(chalk_1.default.green(`[WarehouseMock] Mock 目录已创建: ${mockPath}`));
-                this.createDemoFile(mockPath);
-            }
-            catch (err) {
-                console.error(chalk_1.default.red(`[WarehouseMock] 创建 Mock 目录失败: ${err}`));
-            }
-        }
-    }
-    createDemoFile(mockPath) {
-        const demoFilePath = path_1.default.join(mockPath, 'demo.json');
-        const demoContent = {
-            code: 0,
-            msg: 'success',
-            data: {
-                message: '这是自动生成的 demo 数据',
-                id: 1,
-                name: 'Demo User',
-                description: 'Warehouse Mock 自动创建的示例文件',
-            },
-        };
-        try {
-            fs_1.default.writeFileSync(demoFilePath, JSON.stringify(demoContent, null, 2));
-            console.log(chalk_1.default.green(`[WarehouseMock] 已创建示例 Mock 文件: ${demoFilePath}`));
-        }
-        catch (e) {
-            console.error(chalk_1.default.yellow(`[WarehouseMock] 创建示例文件失败: ${e}`));
-        }
-    }
-    // 读取接口配置
-    readInterfaceConfig(apiName, mockPath) {
-        const configPath = path_1.default.join(mockPath, apiName, '.config.json');
-        if (fs_1.default.existsSync(configPath)) {
-            try {
-                const content = fs_1.default.readFileSync(configPath, 'utf-8');
-                return JSON.parse(content);
-            }
-            catch (e) {
-                return null;
-            }
-        }
-        return null;
-    }
-    handleRequest(req, res, next, mockPath) {
-        var _a, _b, _c;
-        const url = req.path || ((_a = req.url) === null || _a === void 0 ? void 0 : _a.split('?')[0]);
-        if (!url) {
-            return next();
-        }
-        // ============ 特殊端点：实时返回 mock 文件列表 ============
-        if (url === '/__mock_list__') {
-            const fileList = this.getMockFileList();
-            res.setHeader('Content-Type', 'application/json');
-            res.setHeader('Cache-Control', 'no-cache, no-store, must-revalidate');
-            res.end(JSON.stringify({
-                mockList: fileList,
-                localApiPrefix: this.getLocalApiPrefix(),
-                proxy: ((_b = this.options.proxy) === null || _b === void 0 ? void 0 : _b.target) || null,
-                enabled: this.isEnabled,
-            }));
-            return;
-        }
-        // 安全检查：防止目录遍历
-        if (url.includes('..')) {
-            return next();
-        }
-        // 检查是否在允许的 API 前缀范围内
-        const { apiPrefixes } = this.options;
-        const isApiRequest = (_c = apiPrefixes === null || apiPrefixes === void 0 ? void 0 : apiPrefixes.some((prefix) => url.startsWith(prefix))) !== null && _c !== void 0 ? _c : true;
-        if (!isApiRequest) {
-            return next();
-        }
-        let filePath = '';
-        let matched = false;
-        let matchedName = '';
-        let interfaceConfig = null;
-        // 1. 优先尝试 Query String 匹配 (RPC 风格接口，如 /api?user.taurus.pointInfo)
-        if (req.url && req.url.includes('?')) {
-            const queryPart = req.url.split('?')[1];
-            if (queryPart) {
-                const params = new URLSearchParams(queryPart);
-                for (const key of params.keys()) {
-                    // 先尝试目录模式（优先，支持多场景）
-                    const dirPath = path_1.default.join(mockPath, key);
-                    if (fs_1.default.existsSync(dirPath) && fs_1.default.statSync(dirPath).isDirectory()) {
-                        // 读取接口配置（新格式）
-                        const config = this.readInterfaceConfig(key, mockPath);
-                        if (config) {
-                            // 新格式：检查是否启用
-                            if (config.enabled === false) {
-                                console.log(chalk_1.default.yellow(`[WarehouseMock] ✗ 接口已禁用: ${key}`));
-                                break; // 接口被禁用，不拦截
-                            }
-                            // 根据 activeScene 读取场景文件
-                            const activeScene = config.activeScene || 'default';
-                            const sceneFilePath = path_1.default.join(dirPath, `${activeScene}.json`);
-                            if (fs_1.default.existsSync(sceneFilePath)) {
-                                filePath = sceneFilePath;
-                                matchedName = key;
-                                matched = true;
-                                interfaceConfig = config;
-                                break;
-                            }
-                        }
-                        else {
-                            // 旧格式：查找 mock: true 的文件（向后兼容）
-                            const files = fs_1.default.readdirSync(dirPath).filter(f => f.endsWith('.json') && f !== '.config.json');
-                            for (const file of files) {
-                                const fullPath = path_1.default.join(dirPath, file);
-                                try {
-                                    const content = fs_1.default.readFileSync(fullPath, 'utf-8');
-                                    const jsonData = JSON.parse(content);
-                                    if (jsonData.mock === true) {
-                                        filePath = fullPath;
-                                        matchedName = key;
-                                        matched = true;
-                                        break;
-                                    }
-                                }
-                                catch (e) {
-                                    // 文件解析失败，跳过
-                                }
-                            }
-                            if (matched)
-                                break;
-                        }
-                    }
-                    // 再尝试单文件模式（向后兼容）
-                    if (!matched) {
-                        const queryFilePath = path_1.default.join(mockPath, `${key}.json`);
-                        if (fs_1.default.existsSync(queryFilePath) && fs_1.default.statSync(queryFilePath).isFile()) {
-                            filePath = queryFilePath;
-                            matchedName = key;
-                            matched = true;
-                            break;
-                        }
-                    }
-                    // 也尝试匹配 value (例如 method=user.taurus.pointInfo)
-                    const value = params.get(key);
-                    if (value && !matched) {
-                        const valueDirPath = path_1.default.join(mockPath, value);
-                        if (fs_1.default.existsSync(valueDirPath) && fs_1.default.statSync(valueDirPath).isDirectory()) {
-                            // 读取接口配置（新格式）
-                            const config = this.readInterfaceConfig(value, mockPath);
-                            if (config) {
-                                // 新格式：检查是否启用
-                                if (config.enabled === false) {
-                                    console.log(chalk_1.default.yellow(`[WarehouseMock] ✗ 接口已禁用: ${value}`));
-                                    break;
-                                }
-                                // 根据 activeScene 读取场景文件
-                                const activeScene = config.activeScene || 'default';
-                                const sceneFilePath = path_1.default.join(valueDirPath, `${activeScene}.json`);
-                                if (fs_1.default.existsSync(sceneFilePath)) {
-                                    filePath = sceneFilePath;
-                                    matchedName = value;
-                                    matched = true;
-                                    interfaceConfig = config;
-                                    break;
-                                }
-                            }
-                            else {
-                                // 旧格式：查找 mock: true 的文件（向后兼容）
-                                const files = fs_1.default.readdirSync(valueDirPath).filter(f => f.endsWith('.json') && f !== '.config.json');
-                                for (const file of files) {
-                                    const fullPath = path_1.default.join(valueDirPath, file);
-                                    try {
-                                        const content = fs_1.default.readFileSync(fullPath, 'utf-8');
-                                        const jsonData = JSON.parse(content);
-                                        if (jsonData.mock === true) {
-                                            filePath = fullPath;
-                                            matchedName = value;
-                                            matched = true;
-                                            break;
-                                        }
-                                    }
-                                    catch (e) {
-                                        // 跳过
-                                    }
-                                }
-                                if (matched)
-                                    break;
-                            }
-                        }
-                        if (!matched) {
-                            const valueFilePath = path_1.default.join(mockPath, `${value}.json`);
-                            if (fs_1.default.existsSync(valueFilePath) && fs_1.default.statSync(valueFilePath).isFile()) {
-                                filePath = valueFilePath;
-                                matchedName = value;
-                                matched = true;
-                                break;
-                            }
-                        }
-                    }
-                }
-            }
-        }
-        // 2. 尝试扁平化命名 (将路径中的 / 替换为 _)
-        if (!matched) {
-            const flatName = url.replace(/^\//, '').replace(/\//g, '_') || 'index';
-            const flatFilePath = path_1.default.join(mockPath, `${flatName}.json`);
-            if (fs_1.default.existsSync(flatFilePath) && fs_1.default.statSync(flatFilePath).isFile()) {
-                filePath = flatFilePath;
-                matchedName = flatName;
-                matched = true;
-            }
-        }
-        // 3. 尝试嵌套目录结构匹配 (向后兼容)
-        if (!matched) {
-            const nestedFilePath = path_1.default.join(mockPath, url + '.json');
-            if (fs_1.default.existsSync(nestedFilePath) && fs_1.default.statSync(nestedFilePath).isFile()) {
-                filePath = nestedFilePath;
-                matchedName = url;
-                matched = true;
-            }
-            else {
-                const indexFilePath = path_1.default.join(mockPath, url, 'index.json');
-                if (fs_1.default.existsSync(indexFilePath) && fs_1.default.statSync(indexFilePath).isFile()) {
-                    filePath = indexFilePath;
-                    matchedName = url + '/index';
-                    matched = true;
-                }
-            }
-        }
-        if (matched) {
-            console.log(chalk_1.default.green(`[WarehouseMock] ✓ 拦截: ${req.url || url}`));
-            // 获取延时配置（优先使用接口级别的 delay）
-            const delayTime = (interfaceConfig === null || interfaceConfig === void 0 ? void 0 : interfaceConfig.delay) !== undefined
-                ? interfaceConfig.delay
-                : this.options.delay || 0;
-            // 获取场景名称
-            const sceneName = (interfaceConfig === null || interfaceConfig === void 0 ? void 0 : interfaceConfig.activeScene) || path_1.default.basename(filePath, '.json');
-            console.log(chalk_1.default.gray(`  → 场景: ${sceneName}`));
-            if (delayTime > 0) {
-                console.log(chalk_1.default.gray(`  → 延迟: ${delayTime}ms`));
-            }
-            // 模拟网络延迟
-            const respond = () => {
-                try {
-                    const fileContent = fs_1.default.readFileSync(filePath, 'utf-8');
-                    try {
-                        const jsonData = JSON.parse(fileContent);
-                        // 新格式：纯净的场景数据（不包含 mock、scene、delay 等元数据）
-                        // 旧格式：包含 mock、scene、delay、data 字段
-                        let responseData = jsonData;
-                        // 兼容旧格式
-                        if (jsonData.mock !== undefined && jsonData.data !== undefined) {
-                            responseData = jsonData.data;
-                        }
-                        res.setHeader('Content-Type', 'application/json');
-                        res.setHeader('X-Mock-By', 'WarehouseMock');
-                        res.setHeader('X-Mock-Scene', sceneName);
-                        res.end(JSON.stringify(responseData));
-                    }
-                    catch (jsonErr) {
-                        console.warn(chalk_1.default.yellow(`[WarehouseMock] 无效的 JSON 文件: ${filePath}`));
-                        res.setHeader('Content-Type', 'text/plain');
-                        res.end(fileContent);
-                    }
-                }
-                catch (e) {
-                    console.error(chalk_1.default.red(`[WarehouseMock] 读取 Mock 文件失败: ${e}`));
-                    res.statusCode = 500;
-                    res.end('Mock Read Error');
-                }
-            };
-            // 应用延迟
-            if (delayTime > 0) {
-                setTimeout(respond, delayTime);
-            }
-            else {
-                respond();
-            }
-            return;
-        }
-        // 未匹配到 Mock 文件
-        if (this.options.proxy) {
-            // 如果配置了代理，转发到真实 API
-            console.log(chalk_1.default.gray(`[WarehouseMock] ⊳ 代理: ${req.url || url} → ${this.options.proxy.target}`));
-            this.proxyRequest(req, res, next);
-        }
-        else {
-            // 未配置代理，直接放行
-            next();
-        }
-    }
-    /**
-     * 代理请求到真实 API（改进版）
-     */
-    proxyRequest(req, res, next) {
-        if (!this.options.proxy) {
-            return next();
-        }
-        try {
-            const http = require('http');
-            const https = require('https');
-            const url = require('url');
-            // 构建完整的目标 URL
-            // 将 /mock-api?xxx 转换为 真实API/api?xxx
-            const targetUrl = this.options.proxy.target + req.url.replace('/mock-api', '/api');
-            const parsedUrl = url.parse(targetUrl);
-            const isHttps = parsedUrl.protocol === 'https:';
-            const lib = isHttps ? https : http;
-            // 清理请求头
-            const headers = Object.assign({}, req.headers);
-            delete headers.host;
-            headers.host = parsedUrl.hostname;
-            // 创建代理请求
-            const proxyReq = lib.request({
-                hostname: parsedUrl.hostname,
-                port: parsedUrl.port || (isHttps ? 443 : 80),
-                path: parsedUrl.path,
-                method: req.method,
-                headers: headers,
-                timeout: 30000, // 30秒超时
-            }, (proxyRes) => {
-                // 转发响应头
-                res.writeHead(proxyRes.statusCode, proxyRes.headers);
-                // 转发响应体
-                proxyRes.pipe(res);
-            });
-            // 错误处理
-            proxyReq.on('error', (err) => {
-                console.error(chalk_1.default.red(`[WarehouseMock] 代理请求失败: ${err.message}`));
-                console.error(chalk_1.default.red(`  目标地址: ${targetUrl}`));
-                // 返回友好的错误信息
-                if (!res.headersSent) {
-                    res.statusCode = 502;
-                    res.setHeader('Content-Type', 'application/json');
-                    res.end(JSON.stringify({
-                        code: -1,
-                        msg: `代理请求失败: ${err.message}`,
-                        error: 'PROXY_ERROR'
-                    }));
-                }
-            });
-            // 超时处理
-            proxyReq.on('timeout', () => {
-                proxyReq.destroy();
-                if (!res.headersSent) {
-                    res.statusCode = 504;
-                    res.setHeader('Content-Type', 'application/json');
-                    res.end(JSON.stringify({
-                        code: -1,
-                        msg: '代理请求超时',
-                        error: 'PROXY_TIMEOUT'
-                    }));
-                }
-            });
-            // 转发请求体
-            if (req.method === 'POST' || req.method === 'PUT') {
-                // 处理 POST/PUT 请求的 body
-                let body = '';
-                req.on('data', (chunk) => {
-                    body += chunk.toString();
-                });
-                req.on('end', () => {
-                    if (body) {
-                        proxyReq.write(body);
-                    }
-                    proxyReq.end();
-                });
-            }
-            else {
-                proxyReq.end();
-            }
-        }
-        catch (err) {
-            console.error(chalk_1.default.red(`[WarehouseMock] 代理配置错误: ${err}`));
-            if (!res.headersSent) {
-                res.statusCode = 500;
-                res.setHeader('Content-Type', 'application/json');
-                res.end(JSON.stringify({
-                    code: -1,
-                    msg: `代理配置错误: ${err}`,
-                    error: 'PROXY_CONFIG_ERROR'
-                }));
-            }
-        }
-    }
 }
 module.exports = WarehouseMockPlugin;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "warehouse-mock",
-  "version": "1.1.5",
-  "description": "一个专为 Vue 2 项目设计的 Webpack 插件，支持 RPC 风格接口 mock，零业务代码侵入，实时更新",
+  "version": "1.2.0",
+  "description": "一个专为 Vue 项目设计的 Webpack 插件，支持 RPC 风格接口 mock，零业务代码侵入，实时更新（基于 warehouse-mock-core）",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "files": [
@@ -36,8 +36,7 @@
   "dependencies": {
     "chalk": "^4.1.2",
     "chokidar": "^3.5.3",
-    "i": "^0.3.7",
-    "npm": "^11.7.0"
+    "warehouse-mock-core": "^1.0.0"
   },
   "optionalDependencies": {
     "warehouse-mock-admin": "^1.0.1"