mm_statics 1.9.1 → 1.9.3

package/README.md

@@ -9,7 +9,7 @@
 - 🔄 自动ES6到AMD格式转换
 - ⚡ Vue单文件组件直接转换（无需AMD包装）
 - 🛡️ 安全文件访问
-- 📦 轻量级中间件
+- 🧩 服务式调用 `(params, ctx, options)`，不是中间件、不接收 `next`
 - 🔧 Vue 2/Vue 3兼容性支持
 
 ## 安装
@@ -23,29 +23,38 @@ npm install mm_statics
 ### 基本使用
 
 ```javascript
-const Koa = require('koa');
+const path = require('path');
+const { WebServer } = require('mm_web_server');
 const { statics } = require('mm_statics');
 
-const app = new Koa();
+const web = new WebServer({ name: 'web', port: 3000 });
+const events = web.getEventManager();
 
-// 使用默认配置（root 为 ./static）
-app.use(statics({ root: './static' }));
+// 创建静态资源处理器：签名统一为 (params, ctx, options)
+const serve = statics({ name: 'static', root: path.join(__dirname, 'static'), path: '/' });
 
-app.listen(3000, () => {
-  console.log('服务器运行在 http://localhost:3000');
-});
+// 在 before 阶段挂载：命中文件返回物理路径即短路后续事件，未命中返回空串继续执行
+events.add({ name: 'static', target: '*', stage: 'before', end: true }).main =
+  async (params, ctx, options) => serve(params, ctx, options);
+
+await web.init();
+await web.start();
 ```
 
-### 自定义配置
+### 调用约定
 
-```javascript
-const Koa = require('koa');
-const { statics } = require('mm_statics');
+| 项 | 说明 |
+|---|---|
+| 签名 | `(params, ctx, options)`，与事件管道、适配器保持一致 |
+| 返回值 | 命中返回物理文件路径（字符串），未命中返回空串 |
+| 无 `next` | 未命中也只是返回空串，是否继续由调用方决定，因此它不是中间件 |
+| 响应写出 | 命中时已写出响应（`ctx.res` 直写或 `ctx.set` + `ctx.body`），并标记 `ctx.handled = true` |
 
-const app = new Koa();
+### 自定义配置
 
-// 自定义配置
-app.use(statics({
+```javascript
+const serve = statics({
+  name: 'public',             // 驱动名称（必填）
   root: './public',           // 静态文件根目录
   path: '/src',               // 需要转换的文件路径前缀
   files: ['.js', '.vue'],     // 需要转换的文件类型
@@ -55,15 +64,17 @@ app.use(statics({
   immutable: true,            // 是否启用不可变缓存
   hidden: false,              // 是否支持隐藏文件
   index: 'index.html'         // 默认索引文件
-}));
+});
 
-app.listen(3000);
+// 命中返回文件路径，未命中返回空串
+const file = await serve({ path: '/src/app.js' }, ctx, {});
 ```
 
 ## 配置选项
 
 | 配置项 | 类型 | 默认值 | 描述 |
 |--------|------|--------|------|
+| `name` | string | 无（必填） | 驱动名称 |
 | `root` | string | `''` | 静态文件根目录，为空时由 `dir` 推导，处理器兜底为 `./static` |
 | `path` | string | `''` | 路由根路径，为空时自动生成 `/${app}/` |
 | `files` | array | `['.js', '.vue', '.html']` | 需要转换的文件类型 |
@@ -86,50 +97,54 @@ app.listen(3000);
 
 ```javascript
 // 禁用AMD转换，仅提供静态文件服务
-app.use(statics({
+const serve = statics({
+  name: 'public',
   convert_amd: false,
   compile_vue: false,
   root: './public'
-}));
+});
 ```
 
 ### 2. ES6模块转换
 
 ```javascript
 // 启用AMD转换，自动转换ES6模块
-app.use(statics({
+const serve = statics({
+  name: 'modules',
   convert_amd: true,
   compile_vue: false,
   root: './src',
   path: '/modules',
   files: ['.js', '.ts']
-}));
+});
 ```
 
 ### 3. Vue单文件组件支持（AMD转换）
 
 ```javascript
 // 启用AMD转换，将Vue组件转换为AMD格式
-app.use(statics({
+const serve = statics({
+  name: 'vue',
   convert_amd: true,
   compile_vue: true,
   root: './components',
   path: '/vue',
   files: ['.vue']
-}));
+});
 ```
 
 ### 4. Vue单文件组件直接转换（无需AMD包装）
 
 ```javascript
 // 禁用AMD转换，但启用Vue编译，生成可直接使用的组件
-app.use(statics({
+const serve = statics({
+  name: 'vue_component',
   convert_amd: false,
   compile_vue: true,
   root: './components',
   path: '/vue',
   files: ['.vue']
-}));
+});
 ```
 
 ## Vue组件转换特性
@@ -218,13 +233,20 @@ new Static(config)
 
 #### 方法
 
-- `main(ctx, next)` - 主处理逻辑，作为中间件使用（路径取自 `ctx.path`）
-- `main(ctx, file_path)` - 直接发送指定文件
-- `run(ctx, next)` - 中间件方式处理静态文件
-- `send(ctx, file_path, config)` - 直接发送指定文件
+- `main(params, ctx, options)` - 主处理逻辑，服务式调用；命中返回物理文件路径，未命中返回空串
+- `run(params, ctx, options)` - 与 `main` 等价，委托给内部 `StaticHandle` 处理
+- `send(ctx, file_path, config)` - 直接发送指定文件（低层 API，不参与请求分发）
 - `_delCache(url)` - 删除指定请求路径的服务端缓存
 - `init()` / `start()` / `stop()` - 生命周期方法（继承自 `mm_mod`）
 
+### StaticManager类
+
+- `run(params, ctx, options)` - 依次尝试各驱动；已处理返回 `true`，未命中返回 `false`
+- `add(config)` / `del(name)` / `reload(name)` - 驱动注册、注销、重启
+
+> 说明：本模块已不再是 Koa/Express 风格的中间件，**不接收 `next` 参数**。
+> 未命中时返回空串或 `false`，由调用方（事件管道、`OS._routeRequest` 等）决定是否继续后续处理。
+
 ## 缓存策略
 
 模块支持以下缓存策略：
@@ -243,12 +265,12 @@ new Static(config)
 
 ## 错误处理
 
-模块会自动处理以下错误：
+模块不会自行决定最终状态码，命中失败一律返回空串（管理器返回 `false`），由调用方的响应写出器决定：
 
-- 文件不存在（返回404）
-- 权限不足（返回403）
-- 转换失败（返回500）
-- Vue解析失败（使用回退方案）
+- 文件不存在 / 路径越界：捕获异常后返回空串，交由后续事件或响应层处理
+- 非 GET/HEAD 请求：直接返回空串，不读取文件
+- 转换失败：记录告警并在可用时回退原内容
+- Vue解析失败：使用回退方案，避免整体请求失败
 
 ## 开发指南
 
@@ -306,6 +328,15 @@ ISC License
 
 ## 更新日志
 
+### 未发布（破坏性变更）
+
+- **不再作为中间件**：移除 `next` 参数，`main` / `run` 统一为服务式签名 `(params, ctx, options)`
+- 命中返回物理文件路径，未命中返回空串；`StaticManager.run` 返回布尔值表示是否已处理
+- 仅处理 `GET` / `HEAD`，其它方法直接返回空串（不再读取文件系统）
+- 删除失效的 `_handleRequest`（原实现引用了不存在的 `_handleGetRequest`）
+- `StaticManager.run` 修正为读取注册表驱动列表（此前读 `configs` 恒为空，多驱动分发失效）
+- 同步更新调用方：`mm_os._routeRequest`、`mm_web_server` 示例、模块示例与测试
+
 ### v1.5.2
 - 新增文件监听功能，支持文件修改时自动更新缓存
 - 集成chokidar模块实现稳定的文件监听

package/index.js

@@ -1,35 +1,38 @@
-const Static = require('./lib/static');
-const StaticHandle = require('./lib/static_handle');
-const Manager = require('./lib/manager');
-const Admin = require('mm_corejs').Admin;
-
-const admin = new Admin();
-admin.setClass(Manager);
-
-module.exports = {
-  Static,
-  StaticHandle,
-  Manager,
-  admin,
-  /**
-   * 创建静态文件中间件工厂函数
-   * @param {Object} config 静态文件配置
-   * @returns {Function} 可直接挂载到 Koa / mm_web_server 的中间件函数
-   */
-  statics(config) {
-    const instance = new Static(config);
-    return instance.main.bind(instance);
-  },
+const Static = require('./lib/static');
+const StaticHandle = require('./lib/static_handle');
+const Manager = require('./lib/manager');
+const Admin = require('mm_corejs').Admin;
+
+const admin = new Admin();
+admin.setClass(Manager);
+
+module.exports = {
+  Static,
+  StaticHandle,
+  Manager,
+  admin,
+  /**
+   * 创建静态文件处理器（服务式调用，不是中间件，不接收 next）
+   *
+   * 返回函数签名 `(params, ctx, options)`：命中文件即写出响应并返回物理路径，
+   * 未命中返回空串，由事件管道自行决定是否继续执行后续事件。
+   * @param {Object} config 静态文件配置
+   * @returns {Function} 处理器函数 (params, ctx, options) => Promise<string>
+   */
+  statics(config) {
+    const instance = new Static(config);
+    return instance.main.bind(instance);
+  },
   /**
    * 获取静态文件管理器实例
    * @param {string} scope 作用域名称，为空时使用 os
    * @param {Object} config 管理器配置
    * @returns {Object} 静态文件管理器实例
    */
-  staticAdmin(scope, config) {
-    if (!scope) {
-      scope = 'os';
-    }
-    return admin.get(scope, config);
-  }
-};
+  staticAdmin(scope, config) {
+    if (!scope) {
+      scope = 'os';
+    }
+    return admin.get(scope, config);
+  }
+};

package/lib/manager.js

@@ -13,11 +13,6 @@ class StaticManager extends Manager {
    * @type {object}
    */
   static config = {
-    /**
-     * 名称
-     * @type {string}
-     */
-    name: "",
     /**
      * 标题
      * @type {string}
@@ -55,57 +50,51 @@ class StaticManager extends Manager {
   }
 
   /**
-   * 处理请求
-   * @param {object} ctx Http请求上下文
-   * @param {object} next 跳过函数
+   * 读取请求路径（优先取事件参数，其次取上下文）
+   * @param {object} params 请求参数
+   * @param {object} ctx 请求上下文
+   * @returns {string} 请求路径
    */
-  async _handleRequest(ctx, next) {
-    var md = ctx.method || (ctx.params && ctx.params.method) || '';
-    var path = ctx.path || (ctx.params && ctx.params.path) || '';
-    if (md === "GET" || md === "HEAD") {
-      await this._handleGetRequest(ctx, next, path);
-    } else {
-      await next();
-    }
+  _requestPath(params, ctx) {
+    return (params && params.path) || (ctx && ctx.path) || '';
   }
 
   /**
-   * 处理GET请求
-   * @param {object} ctx Http请求上下文
-   * @param {object} next 跳过函数
+   * 执行请求（服务式调用，不是中间件，不接收 next）
+   * 命中静态文件即写出响应并返回 true；未命中返回 false，由上层继续执行后续事件
+   * @param {object} params 请求参数（可含 path / url / method）
+   * @param {object} ctx 请求上下文
+   * @param {object} options 运行选项
+   * @returns {Promise<boolean>} 已处理返回 true
    */
-  async run(ctx, next) {
-    var done;
+  async run(params, ctx, options) {
+    var path = this._requestPath(params, ctx);
     var infos = this._getInfos();
     var len = infos.length;
-    let path = ctx.path || (ctx.params && ctx.params.path) || '';
     if (path.indexOf(".") !== -1) {
-      done = await this._tryServeFile(ctx, infos, len, async () => {});
-      if (!done) {
-        await next();
-      }
-    } else {
-      await next();
-      await this._handleDirReq(ctx, infos, len, path);
+      return await this._tryServeFile(params, ctx, options, infos, len);
     }
+    return await this._handleDirReq(params, ctx, options, infos, len, path);
   }
 
   /**
    * 尝试提供文件服务
-   * @param {object} ctx Http请求上下文
+   * @param {object} params 请求参数
+   * @param {object} ctx 请求上下文
+   * @param {object} options 运行选项
    * @param {Array} infos 驱动信息列表
    * @param {number} len 列表长度
-   * @param {object} next 跳过函数
-   * @returns {boolean} 是否成功
+   * @returns {Promise<boolean>} 是否命中
    */
-  async _tryServeFile(ctx, infos, len, next) {
+  async _tryServeFile(params, ctx, options, infos, len) {
     for (var i = 0; i < len; i++) {
       var info = infos[i];
-      if (info.state === 1) {
+      let is_running = await this.isRunning(info.name);
+      if (is_running) {
         let mod = this.get(info.name);
         if (mod) {
           await this._initDrive(mod);
-          var done = await mod.run(ctx, next);
+          var done = await mod.run(params, ctx, options);
           if (done) {
             return true;
           }
@@ -117,32 +106,37 @@ class StaticManager extends Manager {
 
   /**
    * 处理目录请求
-   * @param {object} ctx Http请求上下文
+   * @param {object} params 请求参数
+   * @param {object} ctx 请求上下文
+   * @param {object} options 运行选项
    * @param {Array} infos 驱动信息列表
    * @param {number} len 列表长度
    * @param {string} path 请求路径
+   * @returns {Promise<boolean>} 驱动已处理目录请求返回 true，仅重定向或未命中返回 false
    */
-  async _handleDirReq(ctx, infos, len, path) {
+  async _handleDirReq(params, ctx, options, infos, len, path) {
     var q = this._getQueryString(ctx);
     for (var i = 0; i < len; i++) {
       var info = infos[i];
-      if (info.state === 1) {
+      let is_running = await this.isRunning(info.name);
+      if (is_running) {
         let mod = this.get(info.name);
         if (mod) {
           var p = mod.config.path;
           if (path === p) {
             this._handleExactMatch(ctx, q, p);
-            break;
+            return false;
           } else {
             await this._initDrive(mod);
-            var done = await mod.run(ctx, () => {});
+            var done = await mod.run(params, ctx, options);
             if (done) {
-              break;
+              return true;
             }
           }
         }
       }
     }
+    return false;
   }
 
   /**
@@ -171,9 +165,11 @@ class StaticManager extends Manager {
   _handleExactMatch(ctx, q, p) {
     // mm_web_server 原生 ctx 无 status 字段，未设置时视为 404 以兼容旧逻辑
     var status = ctx.status === undefined ? 404 : ctx.status;
-    if (status === 404 && typeof ctx.redirect === 'function') {
+    // 驱动路径已带尾部斜杠时（如根路径 /），请求路径与驱动路径相同即已规范，无需重定向，避免自跳死循环
+    var need_redirect = status === 404 && typeof ctx.redirect === 'function' && !p.endsWith('/');
+    if (need_redirect) {
       // 驱动路径可能已带尾部斜杠，避免拼接出双斜杠
-      var target = p.endsWith('/') ? p : p + '/';
+      var target = p + '/';
       if (q) {
         ctx.redirect(target + "?" + q);
       } else {
@@ -246,15 +242,13 @@ StaticManager.prototype._getInfos = function () {
 };
 
 /**
- * 初始化驱动实例（仅未初始化时执行生命周期 init，重复调用安全）
+ * 初始化驱动实例（重复调用安全由驱动自身保证）
  * @param {object} drive 驱动实例
  * @returns {Promise<void>} 初始化完成
  * @private
  */
 StaticManager.prototype._initDrive = async function (drive) {
-  if (await drive.isState("created")) {
-    await drive.init();
-  }
+  await drive.init();
 };
 
 /**

package/lib/static.js

@@ -17,8 +17,6 @@ class Static extends Item {
     'root': '',
     // 路由根路径
     'path': '',
-    // 名称
-    'name': '',
     // 首页
     'index': 'index.html',
     // 重定向
@@ -154,46 +152,45 @@ Static.prototype._getRoot = function (file) {
 };
 
 /**
- * 执行前
- * @param {object} ctx http请求上下文
- * @param {object} path 文件路径
+ * 执行前钩子
+ * @param {object} params 请求参数
+ * @param {object} ctx 请求上下文
+ * @param {object} options 运行选项
  */
-Static.prototype.before = async function (ctx, path) { };
+Static.prototype.before = async function (params, ctx, options) { };
 
 /**
- * 执行
- * 兼容两种调用方式：
- *  - 中间件方式：main(ctx, next)，文件路径取自 ctx.path / ctx.params.path
- *  - 显式路径方式：main(ctx, file_path)，直接发送指定文件
- * @param {object} ctx http请求上下文
- * @param {object|Function} path 文件路径或下一个中间件
- * @returns {Promise<string>} 发送成功返回物理文件路径，未命中返回空字符串
+ * 主处理函数（服务式调用，不是中间件，不接收 next）
+ * 签名与事件管道保持一致：`main(params, ctx, options)`
+ * @param {object} params 请求参数（可含 path / url / method）
+ * @param {object} ctx 请求上下文
+ * @param {object} options 运行选项
+ * @returns {Promise<string>} 命中返回物理文件路径，未命中返回空串
  */
-Static.prototype.main = async function (ctx, path) {
-  if (typeof path === 'function') {
-    return await this.run(ctx, path);
-  }
-  return await this.send(ctx, path, this.config);
+Static.prototype.main = async function (params, ctx, options) {
+  return await this.run(params, ctx, options);
 };
 
 /**
- * 执行后
- * @param {object} ctx http请求上下文
- * @param {object} path 文件路径
+ * 执行后钩子
+ * @param {object} params 请求参数
+ * @param {object} ctx 请求上下文
+ * @param {object} options 运行选项
  */
-Static.prototype.after = async function (ctx, path) { };
+Static.prototype.after = async function (params, ctx, options) { };
 
 /**
- * 执行静态文件
- * @param {object} ctx Http请求上下文
- * @param {object} next 跳过当前函数
- * @returns {string} 执行成功返回文件路径
+ * 执行静态文件（命中即写出响应，未命中返回空串，由调用方继续后续事件）
+ * @param {object} params 请求参数（可含 path / url / method）
+ * @param {object} ctx 请求上下文
+ * @param {object} options 运行选项
+ * @returns {Promise<string>} 命中返回物理文件路径，未命中返回空串
  */
-Static.prototype.run = async function (ctx, next) {
+Static.prototype.run = async function (params, ctx, options) {
   if (!this.static) {
     this._preset();
   }
-  return await this.static.main(ctx, next);
+  return await this.static.main(params, ctx, options);
 };
 
 /**

package/lib/static_handle.js

@@ -356,7 +356,8 @@ StaticHandle.prototype._checkFilePath = function (file_path) {
  * @returns {object|null} {start, end} 范围对象，无法解析时返回 null
  */
 StaticHandle.prototype._parseRange = function (ctx, total) {
-  const headers = (ctx.params && ctx.params.headers) || (ctx.request && ctx.request.headers) || {};
+  const headers = ctx.headers || (ctx.params && ctx.params.headers)
+    || (ctx.request && ctx.request.headers) || {};
   const range_header = headers['range'];
   if (!range_header) return null;
   const match = /^bytes=(\d*)-(\d*)$/.exec(range_header);
@@ -772,20 +773,67 @@ StaticHandle.prototype._pathToRoot = function (path) {
 }
 
 /**
- * 主处理函数
- * 兼容两种上下文：
- *  - Koa 风格 ctx：使用 ctx.path / ctx.url
- *  - mm_web_server 原生 ctx：从 ctx.params 读取 path，发送文件后标记 ctx.handled
+ * 读取请求路径（优先取事件参数，其次取上下文）
+ * @param {object} params 请求参数
+ * @param {object} ctx 请求上下文
+ * @returns {string} 请求路径
+ */
+StaticHandle.prototype._requestPath = function (params, ctx) {
+  return (params && params.path) || (ctx && ctx.path) || '';
+};
+
+/**
+ * 读取请求方法（兼容参数与上下文两处来源）
+ * @param {object} params 请求参数
+ * @param {object} ctx 请求上下文
+ * @returns {string} 大写的请求方法，缺省为空串
+ */
+StaticHandle.prototype._requestMethod = function (params, ctx) {
+  let method = (params && params.method) || (ctx && ctx.method) || '';
+  return String(method).toUpperCase();
+};
+
+/**
+ * 读取完整请求地址（含查询串，用作缓存键）
+ * @param {object} params 请求参数
  * @param {object} ctx 请求上下文
- * @param {Function} next 跳过当前处理函数
+ * @param {string} path 已解析出的请求路径
+ * @returns {string} 完整请求地址
  */
-StaticHandle.prototype.main = async function (ctx, next) {
-  let p = ctx.path || (ctx.params && ctx.params.path) || '';
-  let url = ctx.url || p; // 使用完整URL（包含查询参数）
+StaticHandle.prototype._requestUrl = function (params, ctx, path) {
+  return (params && params.url) || (ctx && (ctx.url || ctx.path)) || path;
+};
+
+/**
+ * 判断请求方法是否允许读取静态文件
+ * @param {string} method 请求方法
+ * @returns {boolean} GET / HEAD / 未指定方法时返回 true
+ */
+StaticHandle.prototype._isReadable = function (method) {
+  return !method || method === 'GET' || method === 'HEAD';
+};
+
+/**
+ * 主处理函数（服务式调用，不是中间件，不接收 next）
+ *
+ * 约定签名 `main(params, ctx, options)`，由事件管道或上层路由直接调用：
+ *  - 命中文件：写出响应（或返回物理路径由调用方继续处理）并返回物理文件路径；
+ *  - 未命中：直接返回空串，由调用方决定是否继续执行后续事件，无需回调放行。
+ * @param {object} params 请求参数（可含 path / url / method）
+ * @param {object} ctx 请求上下文（可含 path / url / res / set）
+ * @param {object} options 运行选项（保留，供上层透传）
+ * @returns {Promise<string>} 命中返回物理文件路径，未命中返回空串
+ */
+StaticHandle.prototype.main = async function (params, ctx, options) {
+  let p = this._requestPath(params, ctx);
+  if (!this._isReadable(this._requestMethod(params, ctx))) {
+    return '';
+  }
+  // 无扩展名的路径交给目录分支与后续事件处理
   if (p.indexOf('.') === -1) {
-    await next();
     return '';
   }
+  let url = this._requestUrl(params, ctx, p);
   let path = this._getRealPath(p);
 
   // 检查缓存
@@ -805,9 +853,8 @@ StaticHandle.prototype.main = async function (ctx, next) {
     return await this._sendFile(ctx, path);
   }
   catch {
-    await next();
+    return '';
   }
-  return '';
 };
 
 /**

package/package.json

@@ -1,67 +1,67 @@
-{
-    "name": "mm_statics",
-    "version": "1.9.1",
-    "description": "这是超级美眉statics函数模块，用于web服务端statics缓存",
-    "main": "index.js",
-    "scripts": {
-        "test": "mocha tests/index.js",
-        "tests": "mocha tests/*.js"
-    },
-    "repository": {
-        "type": "git",
-        "url": "git+https://gitee.com/qiuwenwu91/mm_statics.git"
-    },
-    "keywords": [
-        "mm_mod",
-        "mm_infra",
-        "mm_common",
-        "statics",
-        "async",
-        "await",
-        "promise",
-        "add",
-        "del",
-        "set",
-        "get",
-        "query",
-        "run",
-        "exec"
-    ],
-    "layer": "infra",
-    "group": "web_infra",
-    "author": "邱文武",
-    "license": "ISC",
-    "bugs": {
-        "url": "https://gitee.com/qiuwenwu91/mm_statics/issues"
-    },
-    "homepage": "https://gitee.com/qiuwenwu91/mm_statics#readme",
-    "files": [
-        "index.js",
-        "lib/vue_compiler.js",
-        "lib/static.js",
-        "lib/static_handle.js",
-        "lib/manager.js",
-        "eslint.config.js",
-        "static/"
-    ],
-    "dependencies": {
-        "@vue/compiler-sfc": "^3.5.44",
-        "abstract-syntax-tree": "^2.25.0",
-        "chokidar": "^5.0.0",
-        "marked": "^18.1.1",
-        "mm_cache": "^1.5.4",
-        "mm_corejs": "^1.1.5",
-        "mm_es6_to_amd": "^1.5.9",
-        "mm_helper": "^1.0.0",
-        "mm_machine": "^3.5.4",
-        "prettier": "^3.9.10"
-    },
-    "devDependencies": {
-        "eslint": "^10.12.0",
-        "eslint-plugin-jsdoc": "^65.3.4",
-        "koa": "^3.2.1",
-        "mm_eslint": "^1.7.7",
-        "mocha": "^12.0.3",
-        "supertest": "^7.3.1"
-    }
-}
+{
+    "name": "mm_statics",
+    "version": "1.9.3",
+    "description": "这是超级美眉statics函数模块，用于web服务端statics缓存",
+    "main": "index.js",
+    "scripts": {
+        "test": "mocha tests/index.js",
+        "tests": "mocha tests/*.js"
+    },
+    "repository": {
+        "type": "git",
+        "url": "git+https://gitee.com/qiuwenwu91/mm_statics.git"
+    },
+    "keywords": [
+        "mm_mod",
+        "mm_infra",
+        "mm_common",
+        "statics",
+        "async",
+        "await",
+        "promise",
+        "add",
+        "del",
+        "set",
+        "get",
+        "query",
+        "run",
+        "exec"
+    ],
+    "layer": "infra",
+    "group": "web_infra",
+    "author": "邱文武",
+    "license": "ISC",
+    "bugs": {
+        "url": "https://gitee.com/qiuwenwu91/mm_statics/issues"
+    },
+    "homepage": "https://gitee.com/qiuwenwu91/mm_statics#readme",
+    "files": [
+        "index.js",
+        "lib/vue_compiler.js",
+        "lib/static.js",
+        "lib/static_handle.js",
+        "lib/manager.js",
+        "eslint.config.js",
+        "static/"
+    ],
+    "dependencies": {
+        "@vue/compiler-sfc": "^3.5.44",
+        "abstract-syntax-tree": "^2.25.0",
+        "chokidar": "^5.0.0",
+        "marked": "^18.1.1",
+        "mm_cache": "^1.5.4",
+        "mm_corejs": "^1.1.5",
+        "mm_es6_to_amd": "^1.5.9",
+        "mm_helper": "^1.0.0",
+        "mm_machine": "^3.5.4",
+        "prettier": "^3.9.10"
+    },
+    "devDependencies": {
+        "eslint": "^10.12.0",
+        "eslint-plugin-jsdoc": "^65.3.4",
+        "koa": "^3.2.1",
+        "mm_eslint": "^1.7.7",
+        "mocha": "^12.0.3",
+        "supertest": "^7.3.1"
+    }
+}