art-template 4.13.3 → 4.13.7

package/LICENSE

@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright (c) 2016-2020 糖饼
+Copyright (c) 2016 糖饼
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -18,4 +18,4 @@ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
+SOFTWARE.

package/README.md

@@ -29,3 +29,9 @@ art-template 是一个简约、超快的模板引擎。它采用作用域预声
 5. 支持 Express、Koa、Webpack
 6. 支持模板继承与子模板
 7. 浏览器版本仅 6KB 大小
+
+-----------------
+
+[捐助我](https://cloud.githubusercontent.com/assets/1791748/25561320/09c9d6d0-2d9c-11e7-8689-1109f3f88f41.png)(微信支付)
+
+[\[AD\] 前端招聘：在海边写代码](https://juejin.im/post/5a2651d06fb9a0451c3a40ad)

package/index.d.ts

@@ -11,7 +11,7 @@ declare type artTemplateDefaults = {
    * whether to automatically encode output statements of template. Setting false will close that functionality
    * escape can prevent XSS attacks
    */
-  escape: boolean;
+  excape: boolean;
   /**
    * enable debug mode. If true: {cache:false, minimize:false, compileDebug:true}
    */
@@ -106,4 +106,4 @@ declare namespace artTemplate {
   function render(source: string, data: any, options?: any): string;
   function compile(source: string, options?: any): (data: any) => string;
 }
-export = artTemplate;
+export = artTemplate;

package/lib/compile/adapter/caches.js

@@ -0,0 +1,19 @@
+"use strict";
+
+var caches = {
+    __data: Object.create(null),
+
+    set: function set(key, val) {
+        this.__data[key] = val;
+    },
+
+    get: function get(key) {
+        return this.__data[key];
+    },
+
+    reset: function reset() {
+        this.__data = {};
+    }
+};
+
+module.exports = caches;

package/lib/compile/adapter/extend.js

@@ -0,0 +1,37 @@
+'use strict';
+
+var toString = Object.prototype.toString;
+var toType = function toType(value) {
+    // Null: 兼容 IE8
+    return value === null ? 'Null' : toString.call(value).slice(8, -1);
+};
+
+/**
+ * 快速继承默认配置
+ * @param   {Object}    options
+ * @param   {?Object}   defaults
+ * @return  {Object}
+ */
+var extend = function extend(target, defaults) {
+    var object = void 0;
+    var type = toType(target);
+
+    if (type === 'Object') {
+        object = Object.create(defaults || {});
+    } else if (type === 'Array') {
+        object = [].concat(defaults || []);
+    }
+
+    if (object) {
+        for (var index in target) {
+            if (Object.hasOwnProperty.call(target, index)) {
+                object[index] = extend(target[index], object[index]);
+            }
+        }
+        return object;
+    } else {
+        return target;
+    }
+};
+
+module.exports = extend;

package/lib/compile/adapter/html-minifier.js

@@ -0,0 +1,29 @@
+'use strict';
+
+function _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } else { return Array.from(arr); } }
+
+var detectNode = typeof window === 'undefined';
+
+/**
+ * HTML 压缩器
+ * @param  {string}     source
+ * @param  {Object}     options
+ * @return {string}
+ */
+var htmlMinifier = function htmlMinifier(source, options) {
+    if (detectNode) {
+        var _htmlMinifierOptions$;
+
+        var _htmlMinifier = require('html-minifier').minify;
+        var htmlMinifierOptions = options.htmlMinifierOptions;
+        var ignoreCustomFragments = options.rules.map(function (rule) {
+            return rule.test;
+        });
+        (_htmlMinifierOptions$ = htmlMinifierOptions.ignoreCustomFragments).push.apply(_htmlMinifierOptions$, _toConsumableArray(ignoreCustomFragments));
+        source = _htmlMinifier(source, htmlMinifierOptions);
+    }
+
+    return source;
+};
+
+module.exports = htmlMinifier;

package/lib/compile/adapter/include.js

@@ -0,0 +1,21 @@
+'use strict';
+
+/**
+ * 载入子模板
+ * @param   {string}    filename
+ * @param   {Object}    data
+ * @param   {Object}    blocks
+ * @param   {Object}    options
+ * @return  {string}
+ */
+var include = function include(filename, data, blocks, options) {
+    var compile = require('../index');
+    options = options.$extend({
+        filename: options.resolveFilename(filename, options),
+        bail: true,
+        source: null
+    });
+    return compile(options)(data, blocks);
+};
+
+module.exports = include;

package/lib/compile/adapter/loader.js

@@ -0,0 +1,22 @@
+'use strict';
+
+var detectNode = typeof window === 'undefined';
+
+/**
+ * 读取模板内容（同步方法）
+ * @param   {string}    filename   模板名
+ * @param   {?Object}   options
+ * @return  {string}
+ */
+var loader = function loader(filename /*, options*/) {
+    /* istanbul ignore else  */
+    if (detectNode) {
+        var fs = require('fs');
+        return fs.readFileSync(filename, 'utf8');
+    } else {
+        var elem = document.getElementById(filename);
+        return elem.value || elem.innerHTML;
+    }
+};
+
+module.exports = loader;

package/lib/compile/adapter/onerror.js

@@ -0,0 +1,13 @@
+"use strict";
+
+/**
+ * 调试器
+ * @param   {Object}    error
+ * @param   {?Object}   options
+ * @return  {string}
+ */
+var onerror = function onerror(error /*, options*/) {
+  console.error(error.name, error.message);
+};
+
+module.exports = onerror;

package/lib/compile/adapter/resolve-filename.js

@@ -0,0 +1,36 @@
+'use strict';
+
+var detectNode = typeof window === 'undefined';
+var LOCAL_MODULE = /^\.+\//;
+
+/**
+ * 获取模板的绝对路径
+ * @param   {string} filename
+ * @param   {Object} options
+ * @return  {string}
+ */
+var resolveFilename = function resolveFilename(filename, options) {
+    /* istanbul ignore else  */
+    if (detectNode) {
+        var path = require('path');
+        var root = options.root;
+        var extname = options.extname;
+
+        if (LOCAL_MODULE.test(filename)) {
+            var from = options.filename;
+            var self = !from || filename === from;
+            var base = self ? root : path.dirname(from);
+            filename = path.resolve(base, filename);
+        } else {
+            filename = path.resolve(root, filename);
+        }
+
+        if (!path.extname(filename)) {
+            filename = filename + extname;
+        }
+    }
+
+    return filename;
+};
+
+module.exports = resolveFilename;

package/lib/compile/adapter/rule.art.js

@@ -0,0 +1,187 @@
+'use strict';
+
+/**
+ * 简洁模板语法规则
+ */
+var artRule = {
+    test: /{{([@#]?)[ \t]*(\/?)([\w\W]*?)[ \t]*}}/,
+    use: function 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 '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 '/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 表达式拆分成组
+    // 支持基本运算、三元表达式、取值、运行函数，不支持 `typeof value` 操作
+    // 只支持 string、number、boolean、null、undefined 这几种类型声明，不支持 function、object、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('');
+        });
+    }
+};
+
+module.exports = artRule;

package/lib/compile/adapter/rule.native.js

@@ -0,0 +1,34 @@
+'use strict';
+
+/**
+ * 原生模板语法规则
+ */
+var nativeRule = {
+    test: /<%(#?)((?:==|=#|[=-])?)[ \t]*([\w\W]*?)[ \t]*(-?)%>/,
+    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.replace(/\*\//g, '* /') + '*/';
+            output = false;
+        }
+
+        // ejs compat: trims following newline
+        // if (trimMode) {}
+
+        return {
+            code: code,
+            output: output
+        };
+    }
+};
+
+module.exports = nativeRule;