mm_tpl 2.7.1 → 2.7.3

package/lib/tpl_rule.js

@@ -0,0 +1,288 @@
+'use strict';
+
+/**
+ * 原生模板语法规则
+ * @type {Object}
+ */
+var nativeRule = {
+  test: /[ \t\r\n]*<!--\[(#?)((?:==|=#|[=-])?)[ \t]*([\w\W]*?)[ \t]*(-?)\]-->/,
+
+  /**
+   * 处理原生模板语法
+   * @param {string} match - 匹配的字符串
+   * @param {string} comment - 注释标记
+   * @param {string} output - 输出类型
+   * @param {string} code - 代码内容
+   * @returns {Object} 处理结果
+   */
+  use: function use(match, comment, output, code /*, trimMode*/) {
+    output = {
+      '-': 'raw',
+      '=': 'escape',
+      '': false,
+      // v3 compat: raw output
+      '==': 'raw',
+      '=#': 'raw'
+    }[output];
+
+    // ejs compat: comment tag
+    if (comment) {
+      code = '/*' + code + '*/';
+      output = false;
+    }
+
+    // ejs compat: trims following newline
+    // if (trimMode) {}
+
+    return {
+      code: code,
+      output: output
+    };
+  }
+};
+
+/**
+ * 简洁模板语法规则
+ * @type {Object}
+ */
+var artRule = {
+  // 表达式内允许出现非嵌套的对象字面量，如 ${@$component('bar', { id: 1 })}
+  // 若只用 [\w\W]*? 会停在第一个 } 上，把对象字面量截断成语法错误
+  test: /[ \t\r\n]*\$\{([@#]?)[ \t]*(\/?)((?:[^{}]|\{[^{}]*\})*?)[ \t]*\}/,
+
+  /**
+   * 处理简洁模板语法
+   * @param {string} match - 匹配的字符串
+   * @param {string} raw - 原始输出标记
+   * @param {string} close - 闭合标记
+   * @param {string} code - 代码内容
+   * @returns {Object} 处理结果
+   */
+  use(match, raw, close, code) {
+    var compiler = this;
+    var options = compiler.options;
+    var esTokens = compiler.getEsTokens(code);
+    var values = esTokens.map(function (token) {
+      return token.value;
+    });
+    var result = {};
+
+    var group = void 0;
+    var output = raw ? 'raw' : false;
+    var key = close + values.shift();
+
+    // 旧版语法升级提示
+    var warn = function warn(oldSyntax, newSyntax) {
+      console.warn((options.filename || 'anonymous') + ':' + (match.line + 1) + ':' + (match.start + 1) + '\n' + (
+        'Template upgrade: ${' + oldSyntax + '} -> ${' + newSyntax + '}'));
+    };
+
+    // v3 compat: #value
+    if (raw === '#') {
+      warn('#value', '@value');
+    }
+
+    switch (key) {
+      case 'set':
+        code = 'var ' + values.join('').trim();
+        break;
+
+      case 'if':
+        code = 'if(' + values.join('').trim() + '){';
+        break;
+
+      case 'else':
+        var indexIf = values.indexOf('if');
+
+        if (~indexIf) {
+          values.splice(0, indexIf + 1);
+          code = '}else if(' + values.join('').trim() + '){';
+        } else {
+          code = '}else{';
+        }
+
+        break;
+
+      case '/if':
+        code = '}';
+        break;
+
+      case 'loop':
+      case 'each':
+        group = artRule._split(esTokens);
+        group.shift();
+
+        if (group[1] === 'as') {
+          // ... v3 compat ...
+          warn('each object as value index', 'each object value index');
+          group.splice(1, 1);
+        }
+
+        var object = group[0] || '$data';
+        var value = group[1] || '$value';
+        var index = group[2] || '$index';
+
+        code = '$each(' + object + ',function(' + value + ',' + index + '){';
+
+        break;
+
+      case '/loop':
+      case '/each':
+        code = '})';
+        break;
+
+      case 'block':
+        group = artRule._split(esTokens);
+        group.shift();
+        code = 'block(' + group.join(',').trim() + ',function(){';
+        break;
+
+      case '/block':
+        code = '})';
+        break;
+
+      case 'echo':
+        key = 'print';
+        warn('echo value', 'value');
+      case 'print':
+      case 'include':
+      case 'extend':
+        if (values.join('').trim().indexOf('(') !== 0) {
+          // 执行函数省略 `()` 与 `,`
+          group = artRule._split(esTokens);
+          group.shift();
+          code = key + '(' + group.join(',') + ')';
+          break;
+        }
+
+      default:
+        if (~values.indexOf('|')) {
+          var v3split = ':'; // ... v3 compat ...
+
+          // 将过滤器解析成二维数组
+          var _group = esTokens.reduce(function (group, token) {
+            var value = token.value,
+              type = token.type;
+
+            if (value === '|') {
+              group.push([]);
+            } else if (type !== 'whitespace' && type !== 'comment') {
+              if (!group.length) {
+                group.push([]);
+              }
+              if (value === v3split && group[group.length - 1].length === 1) {
+                warn('value | filter: argv', 'value | filter argv');
+              } else {
+                group[group.length - 1].push(token);
+              }
+            }
+            return group;
+          }, []).map(function (g) {
+            return artRule._split(g);
+          });
+
+          // 将过滤器管道化
+          code = _group.reduce(function (accumulator, filter) {
+            var name = filter.shift();
+            filter.unshift(accumulator);
+
+            return '$imports.' + name + '(' + filter.join(',') + ')';
+          }, _group.shift().join(' ').trim());
+        }
+
+        output = output || 'escape';
+
+        break;
+    }
+
+    result.code = code;
+    result.output = output;
+    return result;
+  },
+
+  /**
+   * 将多个javascript表达式拆分成组
+   * @param {Array} esTokens - ES令牌数组
+   * @returns {Array} 分组后的表达式数组
+   */
+  _split: function _split(esTokens) {
+    esTokens = esTokens.filter(function (_ref) {
+      var type = _ref.type;
+
+      return type !== 'whitespace' && type !== 'comment';
+    });
+
+    var current = 0;
+    var lastToken = esTokens.shift();
+    var punctuator = 'punctuator';
+    var close = /\]|\)/;
+    var group = [
+      [lastToken]
+    ];
+
+    while (current < esTokens.length) {
+      var esToken = esTokens[current];
+
+      if (esToken.type === punctuator || lastToken.type === punctuator && !close.test(lastToken.value)) {
+        group[group.length - 1].push(esToken);
+      } else {
+        group.push([esToken]);
+      }
+
+      lastToken = esToken;
+
+      current++;
+    }
+
+    return group.map(function (g) {
+      return g.map(function (g) {
+        return g.value;
+      }).join('');
+    });
+  }
+};
+
+/**
+ * HTML注释模板语法规则
+ * @type {Object}
+ */
+var htmlRule = Object.assign({}, artRule, {
+  test: /[ \t\r\n]*<!--\{([@#]?)[ \t]*(\/?)([\w\W]*?)[ \t]*\}-->/
+});
+
+/**
+ * JS注释模板语法规则
+ * @type {Object}
+ */
+var jsRule = Object.assign({}, artRule, {
+  test: /[ \t\r\n]*\/\*\[([@#]?)[ \t]*(\/?)([\w\W]*?)[ \t]*\]\*\//
+});
+
+/**
+ * Python注释模板语法规则
+ * @type {Object}
+ */
+var pyRule = Object.assign({}, artRule, {
+  test: /[ \t\r\n]*##([@#]?)[ \t]*(\/?)([\w\W]*?)[ \t]*##/
+});
+
+/**
+ * Python三引号注释模板语法规则
+ * @type {Object}
+ */
+var pyRule2 = Object.assign({}, artRule, {
+  test: /"""#([@#]?)[ \t]*(\/?)([\w\W]*?)[ \t]*#"""/
+});
+
+module.exports = {
+  htmlRule,
+  jsRule,
+  artRule,
+  nativeRule,
+  pyRule,
+  pyRule2
+};
+
+
+
+

package/lib/util.js

@@ -0,0 +1,196 @@
+const fs = require('fs');
+const crypto = require('crypto');
+
+/**
+ * 模板工具类
+ * 收纳与实例状态无关的纯辅助函数，全部以静态方法提供
+ * @class
+ */
+class TplUtil {
+  /**
+   * 获取文件修改时间
+   * @param {string} file - 文件路径
+   * @returns {number} 修改时间戳，取不到时返回0
+   */
+  static getFileTime(file) {
+    try {
+      return fs.statSync(file).mtimeMs;
+    } catch {
+      return 0;
+    }
+  }
+
+  /**
+   * 转义正则表达式特殊字符
+   * @param {string} str - 原始字符串
+   * @returns {string} 转义后的字符串
+   */
+  static escapeRegExp(str) {
+    return str.replace('\\', '\\\\').replace('$', '\\$').replace('[', '\\[').replace(']', '\\]')
+      .replace('{', '\\{').replace('}', '\\}').replace('/', '\\/').replace('*', '\\*');
+  }
+
+  /**
+   * 构建字符转义规则
+   * 转义时把语法字符替换为中间字符，渲染后再还原，避免与模板语法冲突
+   * @param {Array<string>} change_str - 需要转义与还原的字符串列表
+   * @returns {Object} 转义规则，含 regex_in、str_in、regex_out、str_out
+   */
+  static buildEscapeRule(change_str) {
+    var rule = {
+      regex_in: [],
+      str_in: [],
+      regex_out: [],
+      str_out: []
+    };
+    var lt = change_str || [];
+    for (var i = 0; i < lt.length; i++) {
+      var str = lt[i];
+      rule.regex_in.push(new RegExp(TplUtil.escapeRegExp(str), 'gi'));
+      var str_in = str.split('').join('·') + '·';
+      rule.str_in.push(str_in);
+      rule.regex_out.push(new RegExp(TplUtil.escapeRegExp(str_in), 'gi'));
+      rule.str_out.push(str.replace('\\', ''));
+    }
+    return rule;
+  }
+
+  /**
+   * 转义或还原字符串
+   * @param {string} body - 字符串
+   * @param {Object} rule - 转义规则
+   * @param {boolean} restore - 是否还原
+   * @returns {string} 处理后的字符串
+   */
+  static escape(body, rule, restore) {
+    if (!body) {
+      return body;
+    }
+    var rx = restore ? rule.regex_out : rule.regex_in;
+    var st = restore ? rule.str_out : rule.str_in;
+    for (var i = 0; i < rx.length; i++) {
+      body = body.replace(rx[i], st[i]);
+    }
+    return body;
+  }
+
+  /**
+   * 深度合并对象
+   * 目标已有的键：同为对象则递归合并，类型相同则转换后覆盖，类型不同保持原值
+   * 目标没有的键：supplement 为 true 时补充，否则跳过
+   * @param {Object} target - 被合并的对象
+   * @param {Object} source - 用作合并的对象
+   * @param {boolean} supplement - 是否补充目标没有的键
+   * @returns {Object} 修改后的目标对象
+   */
+  static mergeDeep(target, source, supplement) {
+    if (!target || !source || typeof (target) !== 'object' || typeof (source) !== 'object') {
+      return target;
+    }
+    for (var key in source) {
+      if (Object.prototype.hasOwnProperty.call(target, key)) {
+        var target_val = target[key];
+        var source_val = source[key];
+        if (typeof (target_val) === 'object' && typeof (source_val) === 'object') {
+          TplUtil.mergeDeep(target_val, source_val, supplement);
+        } else if (typeof (target_val) === typeof (source_val)) {
+          target[key] = TplUtil._convertValue(target_val, source_val);
+        }
+      } else if (supplement) {
+        target[key] = source[key];
+      }
+    }
+    return target;
+  }
+
+  /**
+   * 按目标值的类型转换源值
+   * @param {any} target_val - 目标值
+   * @param {any} source_val - 源值
+   * @returns {any} 转换后的值
+   * @private
+   */
+  static _convertValue(target_val, source_val) {
+    var target_type = typeof (target_val);
+    if (target_type === 'number') {
+      var num = Number(source_val);
+      return isNaN(num) ? 0 : num;
+    }
+    if (target_type === 'boolean') {
+      if (source_val === '0' || source_val === 'false' || source_val === 'False') {
+        return false;
+      }
+      if (source_val === '1' || source_val === 'true' || source_val === 'True') {
+        return true;
+      }
+      return Boolean(source_val);
+    }
+    if (target_type === 'string') {
+      return String(source_val);
+    }
+    return source_val;
+  }
+
+  /**
+   * 深拷贝对象或值
+   * 仅处理数组与普通对象，最大递归深度 10，超出时直接返回原值
+   * @param {any} source - 源对象或值
+   * @param {number} depth - 当前递归深度，内部使用
+   * @returns {any} 拷贝后的对象或值
+   * @private
+   */
+  static cloneDeep(source, depth) {
+    var level = depth || 0;
+    if (level > 10 || !source || typeof (source) !== 'object') {
+      return source;
+    }
+    if (Array.isArray(source)) {
+      var new_arr = [];
+      for (var i = 0; i < source.length; i++) {
+        new_arr.push(TplUtil.cloneDeep(source[i], level + 1));
+      }
+      return new_arr;
+    }
+    var new_obj = {};
+    for (var key in source) {
+      if (Object.prototype.hasOwnProperty.call(source, key)) {
+        new_obj[key] = TplUtil.cloneDeep(source[key], level + 1);
+      }
+    }
+    return new_obj;
+  }
+
+  /**
+   * 计算字符串的 MD5 值
+   * @param {string} str - 原始字符串
+   * @returns {string} 十六进制摘要
+   */
+  static md5(str) {
+    return crypto.createHash('md5').update(str + '').digest('hex');
+  }
+
+  /**
+   * 取两个标记符之间的子串
+   * 任一标记符不存在时返回空字符串
+   * @param {string} str - 原始字符串
+   * @param {string} left_str - 左侧标记符
+   * @param {string} right_str - 右侧标记符
+   * @returns {string} 截取后的字符串
+   */
+  static between(str, left_str, right_str) {
+    var start = (str + '').indexOf(left_str);
+    if (start === -1) {
+      return '';
+    }
+    var from = start + left_str.length;
+    var end = (str + '').indexOf(right_str, from);
+    if (end === -1) {
+      return '';
+    }
+    return (str + '').substring(from, end);
+  }
+}
+
+module.exports = {
+  TplUtil
+};

package/package.json

@@ -1,10 +1,13 @@
 {
     "name": "mm_tpl",
-    "version": "2.7.1",
+    "version": "2.7.3",
     "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"
     },
@@ -13,6 +16,10 @@
         "url": "git+https://gitee.com/qiuwenwu91/mm_tpl.git"
     },
     "keywords": [
+        "mm_mod",
+        "mm_infra",
+        "mm_common",
+        "mm_web",
         "template",
         "engine",
         "mvc",
@@ -26,6 +33,8 @@
         "nodejs",
         "javascript"
     ],
+    "layer": "infra",
+    "group": "common",
     "author": "邱文武",
     "license": "MIT",
     "bugs": {
@@ -33,8 +42,7 @@
     },
     "homepage": "https://gitee.com/qiuwenwu91/mm_tpl#readme",
     "dependencies": {
-        "art-template": "^4.13.4",
-        "mm_expand": "^2.5.4"
+        "art-template": "^4.13.4"
     },
     "engines": {
         "node": ">=12.0.0"
@@ -43,8 +51,14 @@
         "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"
+    }
 }