mm_tpl 2.7.2 → 2.7.3

package/lib/base_lang.js

@@ -0,0 +1,200 @@
+/**
+ * 基础语言类
+ * @description 提供语言包字典存储、翻译取词、复数形式选择与占位符插值能力
+ */
+
+/**
+ * 基础语言类
+ * @class BaseLang
+ */
+class BaseLang {
+  /**
+   * 创建语言实例
+   * @param {Object} config 语言包字典，形如 { zh_cn: { key: 值 }, default: 'zh_cn' }
+   */
+  constructor(config) {
+    /**
+     * 语言包字典
+     * @type {Object}
+     */
+    this.config = config || {};
+    /**
+     * 当前语言代码
+     * @type {String}
+     */
+    this.now = this.config.default || 'zh_cn';
+    /**
+     * 复数规则表，键为语言代码，值为根据数量返回复数索引的函数
+     * @type {Object}
+     */
+    this.rules = {
+      zh_cn: function (count) {
+        return 0;
+      },
+      en: function (count) {
+        return count === 1 ? 0 : 1;
+      }
+    };
+  }
+
+  /**
+   * 注册语言复数规则
+   * @param {String} code 语言代码
+   * @param {Function} fn 复数规则函数，入参为数量，返回复数索引
+   * @returns {BaseLang} 当前实例
+   */
+  registerPlural(code, fn) {
+    if (code && typeof fn === 'function') {
+      this.rules[code] = fn;
+    }
+    return this;
+  }
+
+  /**
+   * 设置当前语言
+   * 请求的语言不支持时回退到默认语言
+   * @param {String} lang 语言代码
+   * @returns {String} 设置后的语言代码
+   */
+  setLang(lang) {
+    if (this.isSupported(lang)) {
+      this.now = lang;
+    } else if (this.isSupported(this.config.default)) {
+      this.now = this.config.default;
+    }
+    return this.now;
+  }
+
+  /**
+   * 获取支持的语言列表
+   * 过滤掉配置中的默认语言标记
+   * @returns {Array<String>} 语言代码数组
+   */
+  getLangs() {
+    return Object.keys(this.config).filter(function (key) {
+      return key !== 'default';
+    });
+  }
+
+  /**
+   * 判断语言是否支持
+   * @param {String} lang 语言代码
+   * @returns {Boolean} 支持返回true，否则返回false
+   */
+  isSupported(lang) {
+    return !!lang && lang !== 'default' && typeof this.config[lang] === 'object' && this.config[lang] !== null;
+  }
+
+  /**
+   * 获取翻译词条
+   * 键支持 a.b 层级形式，词条缺失时回退到默认语言
+   * @param {String} key 词条键名
+   * @param {...any} args 位置占位符替换参数，依次替换 {0}、{1} 等
+   * @returns {*} 翻译文本；数组词条不带数量时原样返回
+   */
+  get(key, ...args) {
+    var val = this._getValue(key);
+    if (typeof val !== 'string' || !args.length) {
+      return val;
+    }
+    for (var i = 0; i < args.length; i++) {
+      val = val.split('{' + i + '}').join(args[i]);
+    }
+    return val;
+  }
+
+  /**
+   * 获取带复数形式的翻译文本
+   * @param {String} key 词条键名
+   * @param {Number} count 数量，用于选择复数形式并替换 {count} 占位符
+   * @param {...any} args 位置占位符替换参数
+   * @returns {String} 翻译文本
+   */
+  tc(key, count, ...args) {
+    var val = this._getValue(key);
+    var rule = this.rules[this.now] || this.rules.zh_cn;
+    var index = typeof rule === 'function' ? rule(count) : 0;
+    var text = Array.isArray(val) ? (val[index] || val[0] || '') : (typeof val === 'string' ? val : '');
+    text = String(text).split('{count}').join(count);
+    for (var i = 0; i < args.length; i++) {
+      text = text.split('{' + i + '}').join(args[i]);
+    }
+    return text;
+  }
+
+  /**
+   * 写入词条
+   * 写入当前语言字典，键支持 a.b 层级形式
+   * @param {String} key 词条键名
+   * @param {*} value 词条值
+   * @returns {BaseLang} 当前实例
+   */
+  set(key, value) {
+    var lang = this.config[this.now];
+    if (!lang || typeof lang !== 'object') {
+      lang = {};
+      this.config[this.now] = lang;
+    }
+    setByPath(lang, key, value);
+    return this;
+  }
+
+  /**
+   * 从当前语言字典取值，词条缺失时回退到默认语言
+   * @param {String} key 词条键名
+   * @returns {*} 词条值
+   * @private
+   */
+  _getValue(key) {
+    var now_dict = this.config[this.now];
+    var val = now_dict ? getByPath(now_dict, key) : undefined;
+    if (val === undefined && this.now !== this.config.default) {
+      var def_dict = this.config[this.config.default];
+      if (def_dict) {
+        val = getByPath(def_dict, key);
+      }
+    }
+    return val;
+  }
+}
+
+/**
+ * 按路径从对象中取值
+ * @param {Object} obj 对象
+ * @param {String} path 点号路径
+ * @returns {*} 路径对应的值
+ */
+function getByPath(obj, path) {
+  var keys = String(path).split('.');
+  var val = obj;
+  for (var i = 0; i < keys.length; i++) {
+    if (val === null || val === undefined || typeof val !== 'object') {
+      return undefined;
+    }
+    val = val[keys[i]];
+  }
+  return val;
+}
+
+/**
+ * 按路径向对象写入值
+ * @param {Object} obj 对象
+ * @param {String} path 点号路径
+ * @param {*} value 写入的值
+ * @returns {void}
+ */
+function setByPath(obj, path, value) {
+  var keys = String(path).split('.');
+  var cur = obj;
+  for (var i = 0; i < keys.length - 1; i++) {
+    if (typeof cur[keys[i]] !== 'object' || cur[keys[i]] === null) {
+      cur[keys[i]] = {};
+    }
+    cur = cur[keys[i]];
+  }
+  cur[keys[keys.length - 1]] = value;
+}
+
+module.exports = {
+  BaseLang
+};

package/lib/file.js

@@ -0,0 +1,258 @@
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+/**
+ * 运行根目录，路径补全的默认基准，末尾带路径分隔符
+ */
+var run_path = process.cwd() + path.join('/');
+/**
+ * 系统根目录，@/ 前缀路径的解析基准
+ */
+var root_path = path.resolve();
+
+/**
+ * 文件工具类
+ * 提供路径补全、目录扫描、文件读取等纯函数能力，全部以静态方法提供
+ * 路径规则与 mm_expand 保持一致：/ 开头相对运行根目录、~/ 相对用户主目录、@/ 相对系统根目录，其余按基准目录解析
+ * @class
+ */
+class FileUtil {
+  /**
+   * 获取运行根目录
+   * @returns {string} 运行根目录，末尾带路径分隔符
+   */
+  static getRunPath() {
+    return run_path;
+  }
+
+  /**
+   * 设置运行根目录
+   * @param {string} dir - 新的运行根目录
+   * @returns {string} 设置后的运行根目录
+   */
+  static setRunPath(dir) {
+    if (typeof (dir) !== 'string' || !dir) {
+      return run_path;
+    }
+    run_path = dir.endsWith(path.join('/')) ? dir : dir + path.join('/');
+    return run_path;
+  }
+
+  /**
+   * 补全文件路径
+   * @param {string} file - 文件路径
+   * @param {string} dir - 基准目录，相对路径以此为基准解析
+   * @returns {string} 完整路径
+   */
+  static fullname(file, dir) {
+    if (typeof (file) !== 'string') {
+      throw new Error('file参数必须是字符串');
+    }
+    if (!file) {
+      return run_path || process.cwd();
+    }
+    if (file.startsWith('/') && !file.startsWith('//') && file !== '/') {
+      return FileUtil._handleRootPath(file);
+    }
+    if (file.startsWith('~/')) {
+      return path.resolve(os.homedir(), file.substring(2));
+    }
+    if (file.startsWith('@/')) {
+      return path.resolve(root_path, file.substring(2));
+    }
+    if (file.startsWith('./') || file.startsWith('../')
+      || (!path.isAbsolute(file) && !file.startsWith('/'))) {
+      return FileUtil._handleRelativePath(file, dir);
+    }
+    return file;
+  }
+
+  /**
+   * 判断路径是否为文件
+   * @param {string} file_or_dir - 文件或目录路径
+   * @returns {boolean} 是文件返回true，否则返回false
+   */
+  static isFile(file_or_dir) {
+    try {
+      return fs.statSync(file_or_dir).isDirectory() !== true;
+    } catch {
+      return false;
+    }
+  }
+
+  /**
+   * 判断路径是否为目录
+   * @param {string} file_or_dir - 文件或目录路径
+   * @returns {boolean} 是目录返回true，否则返回false
+   */
+  static isDir(file_or_dir) {
+    try {
+      return fs.statSync(file_or_dir).isDirectory();
+    } catch {
+      return false;
+    }
+  }
+
+  /**
+   * 判断目录是否存在
+   * @param {string} dir - 目录路径
+   * @param {string} base - 基准目录
+   * @returns {boolean} 存在返回true，否则返回false
+   */
+  static hasDir(dir, base) {
+    return fs.existsSync(FileUtil.fullname(dir, base));
+  }
+
+  /**
+   * 判断文件是否存在
+   * @param {string} file - 文件路径
+   * @param {string} base - 基准目录
+   * @returns {boolean} 存在返回true，否则返回false
+   */
+  static hasFile(file, base) {
+    return fs.existsSync(FileUtil.fullname(file, base));
+  }
+
+  /**
+   * 扫描目录下的文件
+   * 只返回一级目录中的文件，keyword 支持 * 通配：*后缀 结尾匹配、前缀* 开头匹配、*包含* 包含匹配
+   * @param {string} dir - 目录路径
+   * @param {string} keyword - 文件名匹配关键词，为空时返回全部文件
+   * @returns {Array<string>} 文件全路径数组
+   */
+  static listFiles(dir, keyword) {
+    var root = FileUtil.fullname(dir);
+    var list = [];
+    var items = [];
+    try {
+      items = fs.readdirSync(root);
+    } catch {
+      return list;
+    }
+    for (var i = 0; i < items.length; i++) {
+      var name = items[i];
+      var f = path.join(root, name);
+      if (FileUtil.isFile(f) && (!keyword || FileUtil._matchName(name, keyword))) {
+        list.push(f);
+      }
+    }
+    return list;
+  }
+
+  /**
+   * 读取文本文件
+   * @param {string} file - 文件路径
+   * @param {string} encode - 编码方式，默认 utf-8
+   * @returns {string|undefined} 文件文本，文件不存在时返回 undefined
+   */
+  static loadText(file, encode) {
+    var f = FileUtil.fullname(file);
+    if (fs.existsSync(f)) {
+      return fs.readFileSync(f, encode || 'utf-8');
+    }
+    return undefined;
+  }
+
+  /**
+   * 读取 JSON 文件
+   * @param {string} file - 文件路径
+   * @returns {Object|null|undefined} 解析后的对象，文件不存在返回 undefined，解析失败返回 null
+   */
+  static loadJson(file) {
+    var f = FileUtil.fullname(file);
+    if (!fs.existsSync(f)) {
+      return undefined;
+    }
+    var text = fs.readFileSync(f, 'utf-8');
+    if (!text) {
+      return undefined;
+    }
+    try {
+      return JSON.parse(text);
+    } catch {
+      return null;
+    }
+  }
+
+  /**
+   * 取路径的目录部分
+   * @param {string} file - 文件路径
+   * @returns {string} 目录路径
+   */
+  static dirname(file) {
+    return path.dirname(file + '');
+  }
+
+  /**
+   * 取路径的基础名
+   * @param {string} file - 文件路径
+   * @returns {string} 基础名
+   */
+  static basename(file) {
+    return path.basename(file + '');
+  }
+
+  /**
+   * 取路径的扩展名
+   * @param {string} file - 文件路径
+   * @returns {string} 扩展名，含点号
+   */
+  static extname(file) {
+    return path.extname(file + '');
+  }
+
+  /**
+   * 处理以 / 开头的路径，相对运行根目录解析
+   * @param {string} file - 文件路径
+   * @returns {string} 完整路径
+   * @private
+   */
+  static _handleRootPath(file) {
+    if (run_path.indexOf(file) === 0 || file.indexOf(run_path) === 0) {
+      return file;
+    }
+    return path.resolve(run_path || process.cwd(), file.substring(1));
+  }
+
+  /**
+   * 处理相对路径，以基准目录或运行根目录为基准解析
+   * @param {string} file - 文件路径
+   * @param {string} dir - 基准目录
+   * @returns {string} 完整路径
+   * @private
+   */
+  static _handleRelativePath(file, dir) {
+    var base_dir = dir && typeof (dir) === 'string' ? dir : run_path;
+    return path.resolve(FileUtil.fullname(base_dir), file);
+  }
+
+  /**
+   * 按关键词匹配文件名
+   * 与关键词全等、或按 * 通配匹配时返回true
+   * @param {string} name - 文件名
+   * @param {string} keyword - 匹配关键词
+   * @returns {boolean} 是否匹配
+   * @private
+   */
+  static _matchName(name, keyword) {
+    if (name === keyword) {
+      return true;
+    }
+    var clean = keyword.replace(/\*/g, '');
+    if (keyword.startsWith('*') && keyword.endsWith('*')) {
+      return name.indexOf(clean) !== -1;
+    }
+    if (keyword.startsWith('*')) {
+      return name.endsWith(clean);
+    }
+    if (keyword.endsWith('*')) {
+      return name.startsWith(clean);
+    }
+    return false;
+  }
+}
+
+module.exports = {
+  FileUtil
+};

package/lib/hook.js

@@ -1,7 +1,9 @@
-
 const {
   types
-} = require("util");
+} = require('util');
+const {
+  TplUtil
+} = require('./util.js');
 
 /**
  * 钩子管理类
@@ -10,8 +12,13 @@ const {
 class Hook {
   /**
    * 创建钩子实例
+   * @param {Object} logger - 日志对象，需含 error 方法，缺省使用 console
    */
-  constructor() {
+  constructor(logger) {
+    /**
+     * 日志对象
+     */
+    this._logger = logger || console;
     this._func = {};
     this._action = {};
     this._filter = {};
@@ -38,11 +45,11 @@ Hook.prototype.sort = function (list) {
 Hook.prototype._getName = function (func, alias) {
   if (!alias) {
     var str = func.toString();
-    var name = str.between('function ', "(").trim();
+    var name = TplUtil.between(str, 'function ', '(').trim();
     if (name) {
       alias = name;
     } else {
-      alias = (new Date()).toString().md5().substring(0, 8);
+      alias = TplUtil.md5((new Date()).toString()).substring(0, 8);
     }
   }
   return alias;
@@ -189,7 +196,7 @@ Hook.prototype.runFunc = async function (name, model, req, ...args) {
           }
         }
       } catch (err) {
-        $.log.error(`[${this.constructor.name}] 执行函数钩子失败 ${item.alias}`, err);
+        this._logger.error(`[${this.constructor.name}] 执行函数钩子失败 ${item.alias}`, err);
       }
     }
   }
@@ -212,7 +219,7 @@ Hook.prototype.runAction = function (name, model, ...args) {
       try {
         ret += o.func(model, ...args);
       } catch (err) {
-        $.log.error(`[${this.constructor.name}] 执行动作钩子失败 ${o.alias}`, err);
+        this._logger.error(`[${this.constructor.name}] 执行动作钩子失败 ${o.alias}`, err);
       }
     }
   }
@@ -235,7 +242,7 @@ Hook.prototype.runFilter = function (name, model, ret, ...args) {
       try {
         ret = item.func(model, ret, ...args) || ret;
       } catch (err) {
-        $.log.error(`[${this.constructor.name}] 执行过滤钩子失败 ${item.alias}`, err);
+        this._logger.error(`[${this.constructor.name}] 执行过滤钩子失败 ${item.alias}`, err);
       }
     }
   }

package/lib/lang.js

@@ -1,9 +1,12 @@
 const {
-  Lang: BaseLang
-} = require('mm_expand');
+  BaseLang
+} = require('./base_lang.js');
 const {
   TplUtil
 } = require('./util.js');
+const {
+  FileUtil
+} = require('./file.js');
 
 /**
  * 语言包加载器
@@ -34,7 +37,7 @@ Lang.prototype.getDirs = function () {
   if (!cg.lang_dir) {
     return [];
   }
-  var dirs = [cg.lang_dir.fullname(tpl.dir)];
+  var dirs = [FileUtil.fullname(cg.lang_dir, tpl.dir)];
   if (!cg.theme_lang_dir) {
     return dirs;
   }
@@ -46,7 +49,7 @@ Lang.prototype.getDirs = function () {
     themes.push(tpl.current_theme);
   }
   for (var i = 0; i < themes.length; i++) {
-    dirs.push(cg.theme_lang_dir.fullname(tpl.getThemeDir(themes[i])));
+    dirs.push(FileUtil.fullname(cg.theme_lang_dir, tpl.getThemeDir(themes[i])));
   }
   return dirs;
 };
@@ -57,13 +60,13 @@ Lang.prototype.getDirs = function () {
  * @returns {Array<string>} 语言包文件路径列表，已排序
  */
 Lang.prototype.getFiles = function (dir) {
-  if (!dir || !dir.hasDir()) {
+  if (!dir || !FileUtil.hasDir(dir)) {
     return [];
   }
-  var files = $.file.get(dir, '*.json');
+  var files = FileUtil.listFiles(dir, '*.json');
   var list = [];
   for (var i = 0; i < files.length; i++) {
-    if (files[i].extname() === '.json') {
+    if (FileUtil.extname(files[i]) === '.json') {
       list.push(files[i]);
     }
   }
@@ -103,15 +106,15 @@ Lang.prototype.loadFiles = function (force) {
   var item = cache[key];
   // 文件未变化时复用缓存，返回副本避免调用方改动污染缓存
   if (!force && item && item.fingerprint === fingerprint) {
-    return $.copy(item.dict);
+    return TplUtil.cloneDeep(item.dict);
   }
   var dict = {};
   for (var i = 0; i < dirs.length; i++) {
     var files = this.getFiles(dirs[i]);
     for (var j = 0; j < files.length; j++) {
       var f = files[j];
-      var lang = f.basename().replace('.json', '');
-      var data = f.loadJson();
+      var lang = FileUtil.basename(f).replace('.json', '');
+      var data = FileUtil.loadJson(f);
       if (!lang || !data || typeof (data) !== 'object') {
         continue;
       }
@@ -119,12 +122,12 @@ Lang.prototype.loadFiles = function (force) {
         dict[lang] = {};
       }
       // 高优先级目录的相同词条覆盖低优先级目录
-      $.push(dict[lang], data, true);
+      TplUtil.mergeDeep(dict[lang], data, true);
     }
   }
   cache[key] = {
     fingerprint: fingerprint,
-    dict: $.copy(dict)
+    dict: TplUtil.cloneDeep(dict)
   };
   return dict;
 };
@@ -139,12 +142,13 @@ Lang.prototype.buildDict = function (force) {
   var dict = this.loadFiles(force);
   var langs = this.tpl.config.langs;
   if (langs && Object.keys(langs).length) {
-    $.push(dict, langs, true);
+    TplUtil.mergeDeep(dict, langs, true);
   }
-  // 未配置任何语言包时，复用全局语言包字典
-  // 深拷贝后再用，避免实例上 lang.set() 写入时改到全局 $.lang.config，进而污染其他实例
+  // 未配置任何语言包时，复用全局语言包字典 global_dict
+  // 深拷贝后再用，避免实例上 lang.set() 写入时改到全局字典，进而污染其他实例
   if (!Object.keys(dict).length) {
-    dict = ($.lang && $.lang.config) ? $.copy($.lang.config) : {};
+    var global_dict = this.tpl.constructor.global_dict;
+    dict = (global_dict && Object.keys(global_dict).length) ? TplUtil.cloneDeep(global_dict) : {};
   }
   return Object.assign({}, dict);
 };

package/lib/memory.js

@@ -98,6 +98,4 @@ Memory.prototype._key = function (user_id) {
   return String(user_id);
 };
 
-module.exports = {
-  Memory
-};
+module.exports = Memory;

package/lib/sqlite.js

@@ -171,6 +171,4 @@ Sqlite.prototype._val = function (value) {
   return (typeof (value) === 'string') ? value : null;
 };
 
-module.exports = {
-  Sqlite
-};
+module.exports = Sqlite;

package/lib/template.js

@@ -1,3 +1,7 @@
+const {
+  FileUtil
+} = require('./file.js');
+
 /**
  * 模板文件加载器
  * 模板按目录优先级覆盖：高优先级目录存在同名文件时覆盖低优先级目录的同名文件
@@ -27,7 +31,7 @@ Template.prototype.hasTheme = function (theme) {
   if (!theme) {
     return false;
   }
-  return this.tpl.getThemeDir(theme).hasDir();
+  return FileUtil.hasDir(this.tpl.getThemeDir(theme));
 };
 
 /**
@@ -47,7 +51,7 @@ Template.prototype.hasStyle = function (style) {
     themes.push(cg.default_theme);
   }
   for (var i = 0; i < themes.length; i++) {
-    if (themes[i] && tpl.getStyleDir(themes[i], style).hasDir()) {
+    if (themes[i] && FileUtil.hasDir(tpl.getStyleDir(themes[i], style))) {
       return true;
     }
   }
@@ -72,16 +76,16 @@ Template.prototype._fixExt = function (file) {
  * 按目录优先级搜索文件
  * @param {string} file - 文件名
  * @param {Array<string>} dirs - 目录列表，顺序即优先级，为空时视为未命中
- * @returns {string} 命中的文件全路径；未命中时返回最后一个候选路径，其 hasFile() 为 false
+ * @returns {string} 命中的文件全路径；未命中时返回最后一个候选路径，其 FileUtil.hasFile 为 false
  */
 Template.prototype._locate = function (file, dirs) {
   if (!dirs.length) {
-    // 返回不存在的路径，交由调用方按 hasFile() 判断
-    return file.fullname(this.tpl.dir) + '.not-exist';
+    // 返回不存在的路径，交由调用方按 FileUtil.hasFile 判断
+    return FileUtil.fullname(file, this.tpl.dir) + '.not-exist';
   }
-  var f = file.fullname(dirs[0]);
-  for (var i = 1; i < dirs.length && !f.hasFile(); i++) {
-    f = file.fullname(dirs[i]);
+  var f = FileUtil.fullname(file, dirs[0]);
+  for (var i = 1; i < dirs.length && !FileUtil.hasFile(f); i++) {
+    f = FileUtil.fullname(file, dirs[i]);
   }
   return f;
 };
@@ -99,7 +103,7 @@ Template.prototype.getFile = function (file, options) {
     throw new Error('模板文件路径必须是字符串');
   }
   file = this._fixExt(file);
-  var dirs = (options && options.dir) ? [options.dir.fullname(this.tpl.dir)] : this.tpl.getTemplateDirs();
+  var dirs = (options && options.dir) ? [FileUtil.fullname(options.dir, this.tpl.dir)] : this.tpl.getTemplateDirs();
   return this._locate(file, dirs);
 };
 
@@ -116,7 +120,7 @@ Template.prototype.getComponent = function (name, options) {
     throw new Error('组件名称必须是字符串');
   }
   var file = this._fixExt(name.replace(/^\.\//, ''));
-  var dirs = (options && options.dir) ? [options.dir.fullname(this.tpl.dir)] : this.tpl.getComponentDirs();
+  var dirs = (options && options.dir) ? [FileUtil.fullname(options.dir, this.tpl.dir)] : this.tpl.getComponentDirs();
   return this._locate(file, dirs);
 };