mm_tpl 2.8.0 → 2.10.0

package/README.md

@@ -177,7 +177,7 @@ const eachResult = tpl.render(`
 
 ```javascript
 // 设置全局数据
-Tpl.global_bag.siteName = "我的网站";
+Tpl.global_bag.set('siteName', "我的网站");
 
 // 设置视图变量
 tpl.set({
@@ -746,8 +746,8 @@ const restored = tpl.escape(escaped, true);
 // 全局钩子单例，往里加的钩子对所有实例生效
 Tpl.global_hook.addAction('header', function (m) { return '<header>头部</header>'; });
 
-// 全局数据袋，渲染时注入模型的 globalBag 字段
-Tpl.global_bag.siteName = '我的网站';
+// 全局数据袋（mm_vars 变量实例，varsAdmin('os') 共用），渲染时以 list() 副本注入模型的 globalBag 字段
+Tpl.global_bag.set('siteName', '我的网站');
 
 // 全局语言包字典，lang_dir 与 langs 都为空时实例按深拷贝副本兜底复用
 Tpl.global_dict = { zh_cn: { name: '超级美眉' }, en: { name: 'MM' } };

package/README_EN.md

@@ -175,7 +175,7 @@ const eachResult = tpl.render(`
 
 ```javascript
 // Set global data
-Tpl.global_bag.siteName = "My Website";
+Tpl.global_bag.set('siteName', "My Website");
 
 // Set view variables
 tpl.set({
@@ -753,7 +753,7 @@ The module mounts no global variables; state shared across instances lives on st
 Tpl.global_hook.addAction('header', function (m) { return '<header>Header</header>'; });
 
 // Global data bag, injected into the model's globalBag field at render time
-Tpl.global_bag.siteName = 'My Website';
+Tpl.global_bag.set('siteName', 'My Website');
 
 // Global language dictionary, used as a deep-copied fallback when both lang_dir and langs are empty
 Tpl.global_dict = { zh_cn: { name: 'MM Girl' }, en: { name: 'MM' } };

package/lib/hook.js

@@ -1,59 +1,80 @@
-const {
-  types
-} = require('util');
-const {
-  TplUtil
-} = require('./util.js');
+const mm_action = require('mm_action');
+const mm_filter = require('mm_filter');
+const mm_func = require('mm_func');
 
 /**
- * 钩子管理类
+ * 钩子管理类（组合门面）
+ *
+ * 组合 mm_action（动作钩子）、mm_filter（过滤钩子）、mm_func（函数钩子）
+ * 三个基础模块，对上保持原有 Hook 公共 API 不变：
+ * - addAction / delAction / runAction  —— 委托给 mm_action
+ * - addFilter / delFilter / runFilter  —— 委托给 mm_filter
+ * - addFunc  / delFunc   / runFunc     —— 委托给 mm_func
+ *
+ * 三个基础模块实例均通过 xxxAdmin(scope) 的 Admin 工厂按作用域注册：
+ * - 相同作用域的 Hook 共用同一组钩子实例（Admin 按名称缓存），
+ *   默认作用域为 os（代表整个系统通用），外部模块可用
+ *   require('mm_action').actionAdmin('os') 等方式直接拿到
+ *   mm_tpl 全局钩子正在使用的实例，实现共用与统一管理；
+ * - 实例级钩子需要隔离时，由调用方通过 Hook.genScope() 显式生成
+ *   唯一作用域传入。
+ *
  * @class
  */
 class Hook {
+  /**
+   * 默认作用域（系统级通用），与其他模块的 xxxAdmin('os') 统一
+   */
+  static GLOBAL_SCOPE = 'os';
+
+  /**
+   * 生成唯一作用域名（tpl_hook_N），供需要实例级隔离的调用方使用
+   * @returns {string} 唯一作用域名称
+   */
+  static genScope() {
+    Hook._seq = (Hook._seq || 0) + 1;
+    return `tpl_hook_${Hook._seq}`;
+  }
+
   /**
    * 创建钩子实例
    * @param {Object} logger - 日志对象，需含 error 方法，缺省使用 console
+   * @param {string} [scope] - 作用域名称，缺省为 os（系统级通用）；
+   *   相同作用域共用同一组钩子实例，需要隔离时传入 Hook.genScope() 生成的唯一作用域
    */
-  constructor(logger) {
+  constructor(logger, scope) {
     /**
      * 日志对象
      */
     this._logger = logger || console;
-    this._func = {};
-    this._action = {};
-    this._filter = {};
+    /**
+     * 作用域名称
+     */
+    this._scope = scope || Hook.GLOBAL_SCOPE;
+    this.scope = this._scope;
+    /**
+     * 动作钩子模块（Admin 按作用域注册/共用）
+     */
+    this.action = mm_action.actionAdmin(this._scope, { logger: this._logger });
+    /**
+     * 过滤钩子模块（Admin 按作用域注册/共用）
+     */
+    this.filter = mm_filter.filterAdmin(this._scope, { logger: this._logger });
+    /**
+     * 函数钩子模块（Admin 按作用域注册/共用）
+     */
+    this.func = mm_func.funcAdmin(this._scope, { logger: this._logger });
   }
-}
 
-/**
- * 排序钩子列表
- * @param {Array} list - 钩子列表
- * @returns {Array} 排序后的列表
- */
-Hook.prototype.sort = function (list) {
-  return list.sort((o1, o2) => {
-    return o2.sort - o1.sort
-  });
-};
-
-/**
- * 获取函数别名
- * @param {Function} func - 钩子函数
- * @param {string} alias - 别名
- * @returns {string} 函数别名
- */
-Hook.prototype._getName = function (func, alias) {
-  if (!alias) {
-    var str = func.toString();
-    var name = TplUtil.between(str, 'function ', '(').trim();
-    if (name) {
-      alias = name;
-    } else {
-      alias = TplUtil.md5((new Date()).toString()).substring(0, 8);
-    }
+  /**
+   * 获取作用域名称
+   * 外部模块可用该作用域通过 xxxAdmin(scope) 拿到同一组钩子实例
+   * @returns {string} 作用域名称
+   */
+  getScope() {
+    return this._scope;
   }
-  return alias;
-};
+}
 
 /**
  * 添加函数钩子
@@ -64,16 +85,7 @@ Hook.prototype._getName = function (func, alias) {
  * @returns {string} 函数别名
  */
 Hook.prototype.addFunc = function (name, func, sort = 100, alias = "") {
-  alias = this._getName(func, alias);
-  var obj = {
-    func,
-    sort,
-    alias
-  }
-  var arr = this._func[name] || [];
-  arr.push(obj);
-  this._func[name] = this.sort(arr);
-  return alias;
+  return this.func.addFunc(name, func, sort, alias);
 };
 
 /**
@@ -85,20 +97,14 @@ Hook.prototype.addFunc = function (name, func, sort = 100, alias = "") {
  * @returns {string} 函数别名
  */
 Hook.prototype.addAction = function (name, func, sort = 100, alias = "") {
-  alias = this._getName(func, alias);
-  var obj = {
-    func,
-    sort,
-    alias
-  }
-  var arr = this._action[name] || [];
-  arr.push(obj);
-  this._action[name] = this.sort(arr);
-  return alias;
+  return this.action.addAction(name, func, sort, alias);
 };
 
 /**
  * 添加过滤钩子
+ * mm_tpl 约定过滤函数签名为 func(model, ret, ...args)（模型在前），
+ * mm_filter 约定为 func(value, ...args)（管道值在前），此处做参数顺序适配；
+ * 过滤函数返回假值时保留原值
  * @param {string} name - 钩子名称
  * @param {Function} func - 钩子函数
  * @param {number} sort - 执行顺序
@@ -106,101 +112,52 @@ Hook.prototype.addAction = function (name, func, sort = 100, alias = "") {
  * @returns {string} 函数别名
  */
 Hook.prototype.addFilter = function (name, func, sort = 100, alias = "") {
-  alias = this._getName(func, alias);
-  var obj = {
-    func,
-    sort,
-    alias
-  }
-  var arr = this._filter[name] || [];
-  arr.push(obj);
-  this._filter[name] = this.sort(arr);
-  return alias;
+  alias = mm_filter.Filter.getName(func, alias);
+  return this.filter.addFilter(name, function (value, model, ...args) {
+    return func(model, value, ...args);
+  }, sort, alias);
 };
 
 /**
  * 删除函数钩子
  * @param {String} name 钩子名称
  * @param {String} alias 函数别名
+ * @returns {boolean} 是否删除成功
  */
-Hook.prototype.delFunc = function (name, alias) {
-  var arr = this._func[name];
-  if (arr) {
-    var list = [];
-    for (var i = 0; i < arr.length; i++) {
-      var item = arr[i];
-      if (item.alias !== alias) {
-        list.push(item);
-      }
-    }
-    this._func[name] = list;
-  }
+Hook.prototype.delFunc = function (name, alias = "") {
+  return this.func.delFunc(name, alias);
 };
 
 /**
  * 删除动作钩子
  * @param {String} name 钩子名称
  * @param {String} alias 函数别名
+ * @returns {boolean} 是否删除成功
  */
-Hook.prototype.delAction = function (name, alias) {
-  var arr = this._action[name];
-  if (arr) {
-    var list = [];
-    for (var i = 0; i < arr.length; i++) {
-      var item = arr[i];
-      if (item.alias !== alias) {
-        list.push(item);
-      }
-    }
-    this._action[name] = list;
-  }
+Hook.prototype.delAction = function (name, alias = "") {
+  return this.action.delAction(name, alias);
 };
 
 /**
  * 删除过滤钩子
  * @param {String} name 钩子名称
  * @param {String} alias 函数别名
+ * @returns {boolean} 是否删除成功
  */
 Hook.prototype.delFilter = function (name, alias = "") {
-  var arr = this._filter[name];
-  if (arr) {
-    var list = [];
-    for (var i = 0; i < arr.length; i++) {
-      var item = arr[i];
-      if (item.alias !== alias) {
-        list.push(item);
-      }
-    }
-    this._filter[name] = list;
-  }
+  return this.filter.delFilter(name, alias);
 };
 
 /**
  * 执行函数钩子
  * @param {string} name - 钩子名称
- * @param {Object} param - 参数
- * @param {Function} func - 钩子函数
+ * @param {Object} model - 模型对象
+ * @param {Object} req - 请求参数
+ * @param {...any} args - 附加参数
+ * @returns {Promise<Object>} 执行结果（最后一个真值）
  */
-Hook.prototype.runFunc = async function (name, model, req, ...args) {
-  var ret;
-  var list = this._func[name];
-  if (list) {
-    for (var i = 0; i < list.length; i++) {
-      var item = list[i];
-      try {
-        var ret_new = item.func(model, req, ...args);
-        if (types.isPromise(ret_new)) {
-          ret_new = await ret_new;
-          if (ret_new) {
-            ret = ret_new;
-          }
-        }
-      } catch (err) {
-        this._logger.error(`[${this.constructor.name}] 执行函数钩子失败 ${item.alias}`, err);
-      }
-    }
-  }
-  return ret;
+Hook.prototype.runFunc = function (name, model, req, ...args) {
+  return this.func.runFunc(name, model, req, ...args);
 };
 
 /**
@@ -208,19 +165,15 @@ Hook.prototype.runFunc = async function (name, model, req, ...args) {
  * @param {string} name - 钩子名称
  * @param {Object} model - 模型对象
  * @param {...any} args - 附加参数
- * @returns {Object} 执行结果
+ * @returns {string} 执行结果（各动作返回值按顺序字符串拼接）
  */
 Hook.prototype.runAction = function (name, model, ...args) {
+  var results = this.action.runAction(name, model, ...args);
   var ret = '';
-  var list = this._action[name];
-  if (list) {
-    for (var i = 0; i < list.length; i++) {
-      var o = list[i];
-      try {
-        ret += o.func(model, ...args);
-      } catch (err) {
-        this._logger.error(`[${this.constructor.name}] 执行动作钩子失败 ${o.alias}`, err);
-      }
+  for (var i = 0; i < results.length; i++) {
+    var r = results[i];
+    if (r !== undefined && r !== null) {
+      ret += String(r);
     }
   }
   return ret;
@@ -235,59 +188,18 @@ Hook.prototype.runAction = function (name, model, ...args) {
  * @returns {Object} 过滤后的参数
  */
 Hook.prototype.runFilter = function (name, model, ret, ...args) {
-  var list = this._filter[name];
-  if (list) {
-    for (var i = 0; i < list.length; i++) {
-      var item = list[i];
-      try {
-        ret = item.func(model, ret, ...args) || ret;
-      } catch (err) {
-        this._logger.error(`[${this.constructor.name}] 执行过滤钩子失败 ${item.alias}`, err);
-      }
-    }
-  }
-  return ret;
+  return this.filter.runFilter(name, ret, model, ...args);
 };
-
 /**
  * 删除钩子
+ * 同时删除该别名下的函数钩子、动作钩子与过滤钩子
  * @param {string} name - 钩子名称
  * @param {string} alias - 函数别名
  */
-Hook.prototype.del = function (name, alias) {
-  var arr = this._func[name];
-  if (arr) {
-    var list = [];
-    for (var i = 0; i < arr.length; i++) {
-      var item = arr[i];
-      if (item.alias !== alias) {
-        list.push(item);
-      }
-    }
-    this._func[name] = list;
-  }
-  arr = this._action[name];
-  if (arr) {
-    var list = [];
-    for (var i = 0; i < arr.length; i++) {
-      var item = arr[i];
-      if (item.alias !== alias) {
-        list.push(item);
-      }
-    }
-    this._action[name] = list;
-  }
-  arr = this._filter[name];
-  if (arr) {
-    var list = [];
-    for (var i = 0; i < arr.length; i++) {
-      var item = arr[i];
-      if (item.alias !== alias) {
-        list.push(item);
-      }
-    }
-    this._filter[name] = list;
-  }
+Hook.prototype.del = function (name, alias = "") {
+  this.func.delFunc(name, alias);
+  this.action.delAction(name, alias);
+  this.filter.delFilter(name, alias);
 };
 
 /**
@@ -295,15 +207,9 @@ Hook.prototype.del = function (name, alias) {
  * @param {string} name - 钩子名称
  */
 Hook.prototype.clear = function (name) {
-  if (name) {
-    delete this._func[name];
-    delete this._action[name];
-    delete this._filter[name];
-  } else {
-    this._func = {};
-    this._action = {};
-    this._filter = {};
-  }
+  this.func.clear(name);
+  this.action.clear(name);
+  this.filter.clear(name);
 };
 
-module.exports = Hook;
+module.exports = Hook;

package/lib/lang.js

@@ -154,6 +154,50 @@ Lang.prototype.buildDict = function (force) {
   return Object.assign({}, dict);
 };
 
+/**
+ * 将嵌套语言包字典规范化为 mm_lang 的扁平词条表
+ * mm_lang 的 Lang 只接受 `语言.层级键 → 文本` 的扁平入参，控制键（default、silent）原样保留
+ * @param {Object} dict 语言包字典，语言代码对应嵌套词条对象
+ * @returns {Object} 扁平词条表
+ */
+function flattenLangPack(dict) {
+  var flat = {};
+  for (var key in dict) {
+    if (!Object.prototype.hasOwnProperty.call(dict, key)) {
+      continue;
+    }
+    var val = dict[key];
+    if (val && typeof (val) === 'object' && !Array.isArray(val)) {
+      flattenInto(val, key, flat);
+    } else {
+      flat[key] = val;
+    }
+  }
+  return flat;
+}
+
+/**
+ * 递归展开嵌套词条为点号路径键 - 内部函数
+ * @param {Object} obj 嵌套词条对象
+ * @param {string} prefix 键前缀
+ * @param {Object} flat 输出容器
+ * @returns {void}
+ */
+function flattenInto(obj, prefix, flat) {
+  for (var key in obj) {
+    if (!Object.prototype.hasOwnProperty.call(obj, key)) {
+      continue;
+    }
+    var val = obj[key];
+    var path = prefix + '.' + key;
+    if (val && typeof (val) === 'object' && !Array.isArray(val)) {
+      flattenInto(val, path, flat);
+    } else {
+      flat[path] = val;
+    }
+  }
+}
+
 /**
  * 创建语言实例
  * 语言包字典在实例间共享，仅当前语言各自独立
@@ -166,7 +210,7 @@ Lang.prototype.create = function (config, force) {
   dict.default = config.default_lang || dict.default || 'zh_cn';
   // 词条缺失时静默返回 undefined，日志由模板引擎自身的 log 体系统一输出
   dict.silent = true;
-  var lang = new BaseLang(dict);
+  var lang = new BaseLang(flattenLangPack(dict));
   this.registerPlural(lang, config.plural_rules);
   return lang;
 };

package/lib/tpl.js

@@ -1,4 +1,7 @@
 const engine = require('art-template');
+const {
+  varsAdmin
+} = require('mm_vars');
 const {
   Base
 } = require('./base.js');
@@ -144,13 +147,19 @@ class Tpl extends Base {
    * 全局钩子实例
    * 所有引擎实例共享，与实例级 this.hook 一起参与执行，全局先执行、实例级后执行
    * 宿主应用注册跨实例钩子时使用，如 Tpl.global_hook.addFunc(...)
+   * 以默认作用域 Hook.GLOBAL_SCOPE（os，代表整个系统通用）在 mm_action/mm_filter/mm_func
+   * 的 Admin 工厂中注册，外部模块可用 actionAdmin('os') 等同名作用域取出同一组钩子实例共用
    */
-  static global_hook = new Hook();
+  static global_hook = new Hook(null, Hook.GLOBAL_SCOPE);
   /**
-   * 全局数据袋
-   * 渲染时注入模型的 globalBag 字段，供模板跨实例共享数据
+   * 全局数据袋（mm_vars 变量实例）
+   * 以默认作用域 os（整个系统通用）通过 varsAdmin('os') 获取，
+   * 外部模块可用 require('mm_vars').varsAdmin('os') 取出同一实例，实现共用与统一管理。
+   * 写入用 set(key, value)、读取用 get(key)、删除用 del(key)；
+   * 渲染时以 list() 副本注入模型的 globalBag 字段（模板内直接 m.globalBag.key 取值），
+   * 模板内的修改只影响本次渲染的副本，不会写回全局
    */
-  static global_bag = {};
+  static global_bag = varsAdmin('os');
   /**
    * 全局语言包字典
    * 实例未配置任何语言包时的回退字典，形如 { 语言代码: 词条对象 }
@@ -198,6 +207,18 @@ class Tpl extends Base {
      */
     this.error = null;
 
+    /**
+     * 编译缓存：模板源码（+options 指纹）→ 已编译渲染函数（LRU）
+     * art-template 对字符串源码每次 render 都重新编译，区块页面（几十个模板/请求）
+     * 会把 CPU 耗在重复编译上；body 即缓存键，内容变更后键自然变化，无需手动失效
+     */
+    this._tpl_cache = new Map();
+
+    /**
+     * 编译缓存上限，超过后淘汰最久未命中的条目，可通过 config.cache_size 调整
+     */
+    this._tpl_cache_max = Number(this.config.cache_size) || 512;
+
     /**
      * 字符转义规则
      */
@@ -240,8 +261,10 @@ class Tpl extends Base {
 
     /**
      * 实例级钩子，仅作用于当前实例；与全局钩子 Tpl.global_hook 一起参与执行，全局先执行、实例级后执行
+     * 通过 Hook.genScope() 显式生成唯一作用域（tpl_hook_N）在 Admin 工厂中注册，实例间相互隔离；
+     * 注意不能省略作用域，否则会默认共用系统级 os 作用域，与全局钩子重复执行
      */
-    this.hook = new Hook(this.config.logger);
+    this.hook = new Hook(this.config.logger, Hook.genScope());
 
     /**
      * 初始化
@@ -537,22 +560,14 @@ Tpl.prototype.tc = function (key, count, ...args) {
 
 /**
  * 获取支持的语言列表
- * 过滤掉无词条的语言，Lang 内置的 zh_cn、en 空字典不计入
+ * 语言列表来自 mm_lang 的扁平词条表，无词条的语言不会出现，无需过滤空字典
  * @returns {Array<string>} 语言代码数组
  */
 Tpl.prototype.getLangs = function () {
   if (!this.lang) {
     return [];
   }
-  var langs = this.lang.getLangs();
-  var list = [];
-  for (var i = 0; i < langs.length; i++) {
-    var dict = this.lang.config[langs[i]];
-    if (dict && Object.keys(dict).length) {
-      list.push(langs[i]);
-    }
-  }
-  return list;
+  return this.lang.getLangs();
 };
 
 /**
@@ -580,7 +595,8 @@ Tpl.prototype.loadLang = function (lang) {
     return null;
   }
   this.reloadLangs();
-  var dict = this.lang ? this.lang.config[lang] : null;
+  // 通过 getDict 导出该语言的嵌套词条字典（形态与语言包文件一致）
+  var dict = this.lang ? this.lang.getDict(lang) : null;
   if (!dict) {
     this.log('warn', '语言包不存在：' + lang);
     return null;
@@ -956,14 +972,45 @@ Tpl.prototype._renderMain = function (body, model, options) {
   if (body) {
     var m = Object.assign({}, {
       viewBag: this.viewBag,
-      globalBag: Tpl.global_bag
+      globalBag: Tpl.global_bag.list()
     }, model);
     this.loadFunc(m);
-    ret = this.engine.render(body, m, options);
+    ret = this._getCompiled(body, options)(m);
   }
   return ret;
 };
 
+/**
+ * 获取已编译渲染函数（LRU 缓存）
+ * 未命中时经 engine.compile 编译后入缓存；命中时移至最新位。
+ * options 非空时并入键（编译结果可能受 rules 等选项影响），空 options 直接以源码为键。
+ * @param {string} body - 模板源码（调用方已完成转义）
+ * @param {Object} options - 配置参数
+ * @returns {Function} 渲染函数，入参为数据模型
+ */
+Tpl.prototype._getCompiled = function (body, options) {
+  var key = body;
+  if (options !== undefined && options !== null && Object.keys(options).length) {
+    key = body + '\u0000' + JSON.stringify(options);
+  }
+  var cache = this._tpl_cache;
+  var fn = cache.get(key);
+  if (fn) {
+    // LRU 触碰：删除后重插，使其移到最新位
+    cache.delete(key);
+    cache.set(key, fn);
+    return fn;
+  }
+  // 与 engine.render(body, m, options) 等价：art-template 的 render 内部即 compile(source, options)(data)
+  fn = this.engine.compile(body, options);
+  cache.set(key, fn);
+  if (cache.size > this._tpl_cache_max) {
+    // 淘汰最旧（Map 迭代序即插入序，首个键即最久未触碰）
+    cache.delete(cache.keys().next().value);
+  }
+  return fn;
+};
+
 /**
  * 套用本次渲染的临时选项
  * options.style 与 options.lang 只对当前这次渲染生效，由 _restoreTempOptions 恢复

package/package.json

@@ -1,66 +1,70 @@
-{
-    "name": "mm_tpl",
-    "version": "2.8.0",
-    "description": "Super Meimei Template Engine - High-performance template engine based on art-template with MVC pattern, hook system, theme switching and caching mechanism",
-    "main": "index.js",
-    "io": true,
-    "priority": 100,
-    "scripts": {
-        "dev": "nodemon test.js",
-        "demo": "node example/demo.js",
-        "test": "node test.js",
-        "coverage": "node --experimental-vm-modules node_modules/jest/bin/jest.js --coverage"
-    },
-    "repository": {
-        "type": "git",
-        "url": "git+https://gitee.com/qiuwenwu91/mm_tpl.git"
-    },
-    "keywords": [
-        "mm_mod",
-        "mm_infra",
-        "mm_common",
-        "mm_web",
-        "template",
-        "engine",
-        "mvc",
-        "web",
-        "view",
-        "render",
-        "art-template",
-        "hook",
-        "theme",
-        "cache",
-        "nodejs",
-        "javascript"
-    ],
-    "layer": "infra",
-    "group": "common",
-    "author": "邱文武",
-    "license": "MIT",
-    "bugs": {
-        "url": "https://gitee.com/qiuwenwu91/mm_tpl/issues"
-    },
-    "homepage": "https://gitee.com/qiuwenwu91/mm_tpl#readme",
-    "dependencies": {
-        "art-template": "4.13.4",
-        "mm_corejs": "^1.1.6",
-        "mm_lang": "^2.0.0"
-    },
-    "engines": {
-        "node": ">=12.0.0"
-    },
-    "files": [
-        "index.js",
-        "hook.js",
-        "tpl_rule.js",
-        "lib/",
-        "doc/",
-        "README.md",
-        "README_EN.md",
-        "package.json"
-    ],
-    "devDependencies": {
-        "eslint": "^9.39.5",
-        "eslint-plugin-jsdoc": "^65.0.0"
-    }
-}
+{
+    "name": "mm_tpl",
+    "version": "2.10.0",
+    "description": "Super Meimei Template Engine - High-performance template engine based on art-template with MVC pattern, hook system, theme switching and caching mechanism",
+    "main": "index.js",
+    "io": true,
+    "priority": 100,
+    "scripts": {
+        "dev": "nodemon test.js",
+        "demo": "node example/demo.js",
+        "test": "node test.js",
+        "coverage": "node --experimental-vm-modules node_modules/jest/bin/jest.js --coverage"
+    },
+    "repository": {
+        "type": "git",
+        "url": "git+https://gitee.com/qiuwenwu91/mm_tpl.git"
+    },
+    "keywords": [
+        "mm_mod",
+        "mm_infra",
+        "mm_common",
+        "mm_web",
+        "template",
+        "engine",
+        "mvc",
+        "web",
+        "view",
+        "render",
+        "art-template",
+        "hook",
+        "theme",
+        "cache",
+        "nodejs",
+        "javascript"
+    ],
+    "layer": "infra",
+    "group": "common",
+    "author": "邱文武",
+    "license": "MIT",
+    "bugs": {
+        "url": "https://gitee.com/qiuwenwu91/mm_tpl/issues"
+    },
+    "homepage": "https://gitee.com/qiuwenwu91/mm_tpl#readme",
+    "dependencies": {
+        "art-template": "4.13.4",
+        "mm_action": "^1.1.0",
+        "mm_corejs": "^1.1.6",
+        "mm_filter": "^1.0.0",
+        "mm_func": "^1.0.0",
+        "mm_lang": "^3.0.0",
+        "mm_vars": "^1.0.1"
+    },
+    "engines": {
+        "node": ">=12.0.0"
+    },
+    "files": [
+        "index.js",
+        "hook.js",
+        "tpl_rule.js",
+        "lib/",
+        "doc/",
+        "README.md",
+        "README_EN.md",
+        "package.json"
+    ],
+    "devDependencies": {
+        "eslint": "^9.39.5",
+        "eslint-plugin-jsdoc": "^65.0.0"
+    }
+}