mm_tpl 2.9.0 → 2.11.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' } };
@@ -977,7 +977,7 @@ tpl.clearCache('./zh_cn');
 
 #### 模板函数表
 
-用 `setFunc` 注册模板函数，注册后每次渲染都注入模型，模板内直接按名调用；`removeFunc` 删除，`getFuncs` 取全部：
+用 `setFunc` 注册模板函数，注册后每次渲染都注入模型，模板内直接按名调用；`delFunc` 删除，`getFuncs` 取全部：
 
 ```javascript
 tpl.setFunc('$md', function (text) {
@@ -1024,7 +1024,7 @@ tpl.hook.addAction('header', function (m) { return '<header>实例级</header>';
 - `runHook(name, req, ...args)` - 执行函数钩子（runFunc 别名）
 - `escape(body, restore)` - 转义/还原字符
 - `setFunc(name, func)` - 注册模板函数，每次渲染都注入模型供模板内调用；内置函数与本次 `model` 的同名字段优先
-- `removeFunc(name)` - 删除已注册的模板函数，返回是否存在并删除成功
+- `delFunc(name)` - 删除已注册的模板函数，返回是否存在并删除成功
 - `getFuncs()` - 获取模板函数表
 
 ### Tpl 多用户相关方法

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' } };
@@ -987,7 +987,7 @@ tpl.clearCache('./zh_cn');
 
 #### Template Function Table
 
-Register template functions with `setFunc`; they are injected into the model on every render and can be called by name inside templates. `removeFunc` deletes one and `getFuncs` returns them all:
+Register template functions with `setFunc`; they are injected into the model on every render and can be called by name inside templates. `delFunc` deletes one and `getFuncs` returns them all:
 
 ```javascript
 tpl.setFunc('$md', function (text) {
@@ -1034,7 +1034,7 @@ tpl.hook.addAction('header', function (m) { return '<header>instance-level</head
 - `runHook(name, req, ...args)` - Execute function hooks (alias of runFunc)
 - `escape(body, restore)` - Escape/restore characters
 - `setFunc(name, func)` - Register a template function injected into the model on every render for templates to call; built-in functions and fields of the same name in this call's `model` take precedence
-- `removeFunc(name)` - Delete a registered template function, returns whether it existed and was removed
+- `delFunc(name)` - Delete a registered template function, returns whether it existed and was removed
 - `getFuncs()` - Get the template function table
 
 ### Tpl Multi-user Methods

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/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());
 
     /**
      * 初始化
@@ -921,7 +944,7 @@ Tpl.prototype.setFunc = function (name, func) {
  * @param {string} name - 函数名
  * @returns {boolean} 是否存在并删除成功
  */
-Tpl.prototype.removeFunc = function (name) {
+Tpl.prototype.delFunc = function (name) {
   if (this.funcs[name] === undefined) {
     return false;
   }
@@ -949,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,6 +1,6 @@
 {
     "name": "mm_tpl",
-    "version": "2.9.0",
+    "version": "2.11.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,
@@ -43,8 +43,12 @@
     "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_lang": "^3.0.0"
+        "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"