@kosatyi/ejs 0.0.12 → 0.0.14

package/dist/ejs.mjs

@@ -12,19 +12,15 @@ defaults.path = 'views';
 
 defaults.resolver = null;
 
-defaults.extension = {
-    template: 'ejs',
-    module: 'mjs',
-};
+defaults.extension = 'ejs';
 
 defaults.vars = {
     EXTEND: '$$$',
     BUFFER: '$$a',
     OUTPUT: '$$i',
     LAYOUT: '$$l',
-    MACROS: '$$m',
-    PRINT: '$$j',
     BLOCKS: '$$b',
+    MACRO: '$$m',
     ERROR: '$$e',
     SCOPE: '$$s',
     SAFE: '$$v',
@@ -41,7 +37,6 @@ const typeProp = function () {
     const callback = args.shift();
     return args.filter(callback).pop()
 };
-
 const isFunction = (v) => typeof v === 'function';
 const isString = (v) => typeof v === 'string';
 const isBoolean = (v) => typeof v === 'boolean';
@@ -112,6 +107,8 @@ const extend = (...args) => {
         }, target)
 };
 
+const noop = () => {};
+
 const each = (object, callback) => {
     let prop;
     for (prop in object) {
@@ -160,6 +157,9 @@ const omit = (object, list) => {
     })
 };
 
+const resolve$1 = (value,callback,context) =>
+    Promise.resolve(value).then(callback.bind(context));
+
 const hasProp = (object, prop) => {
     return object && object.hasOwnProperty(prop)
 };
@@ -249,14 +249,13 @@ const match = (regex, text, callback) => {
 };
 /**
  *
- * @param {Object} config
+ * @param {object} config
  * @return {function(*, *): Function}
  * @constructor
  */
 const Compiler = (config) => {
     const token = config.token;
     const vars = config.vars;
-    const module = config.extension.module;
     const matches = [];
     const formats = [];
     const slurp = {
@@ -277,19 +276,15 @@ const Compiler = (config) => {
     const slurpStart = new RegExp([slurp.match, slurp.start].join(''), 'gm');
     const slurpEnd = new RegExp([slurp.end, slurp.match].join(''), 'gm');
     /**
-     * @type Function
+     * @type function
      * @name Compile
      */
     return function (content, path) {
         const { SCOPE, SAFE, BUFFER } = vars;
-        const extension = path.split('.').pop();
         content = content.replace(/[\r\n]+/g, '\n').replace(/^\s+|\s+$/gm, '');
         content = content
             .replace(slurpStart, slurp.start)
             .replace(slurpEnd, slurp.end);
-        if (extension === module) {
-            content = [token.start, content, token.end].join('\n');
-        }
         let source = `${BUFFER}('`;
         match(regex, content, (params, index, offset) => {
             source += symbols(content.slice(index, offset));
@@ -298,6 +293,7 @@ const Compiler = (config) => {
             });
         });
         source += `');`;
+        source = `try{${source}}catch(e){console.info(e)}`;
         source = `with(${SCOPE}){${source}}`;
         source = `${BUFFER}.start();${source}return ${BUFFER}.end();`;
         source += `\n//# sourceURL=${path}`;
@@ -307,6 +303,7 @@ const Compiler = (config) => {
             result.source = `(function(${SCOPE},${BUFFER},${SAFE}){\n${source}\n})`;
             //result.source = result.toString()
         } catch (e) {
+            console.log(e);
             e.filename = path;
             e.source = source;
             throw e
@@ -417,275 +414,345 @@ const Buffer = () => {
         array = store.pop();
         return resolve(result)
     };
+    buffer.error = function(e){
+        throw e
+    };
     buffer.end = function () {
         return resolve(array)
     };
     return buffer
 };
 
-/**
- *
- * @param {{}} instance
- * @method create
- */
-const Component = (instance) => {
-    const defaults = extend({}, instance.props);
-    const create = instance.create;
-    return {
-        element,
-        create,
-        render(props) {
-            return this.create(extend({}, defaults, props))
-        },
-    }
-};
-
-const Scope = (config, methods) => {
+const configure = (config, methods) => {
     /**
      *
      */
-    const { EXTEND, MACROS, LAYOUT, BLOCKS, BUFFER } = config.vars;
-
+    const { EXTEND, LAYOUT, BLOCKS, BUFFER, MACRO, SCOPE } = config.vars;
     /**
-     *
+     * @memberOf global
+     * @name [SCOPE]
      * @param data
      * @constructor
      */
     function Scope(data = {}) {
-        this.setBlocks({});
+        this.initBlocks();
+        this.initMacro();
         extend(this, data);
-        this.setLayout(false);
-        this.setExtend(false);
     }
     /**
-     *
+     * @static
+     * @param methods
+     */
+    Scope.helpers = (methods) => {
+        extend(Scope.prototype, methods);
+    };
+    /**
+     * @static
+     * @param name
+     * @param descriptor
+     */
+    Scope.property = (name, descriptor) => {
+        Object.defineProperty(Scope.prototype, name, descriptor);
+    };
+    /**
+     * @static
+     * @param name
+     * @param method
      */
-    Object.defineProperties(Scope.prototype, {
-        [BUFFER]: {
-            value: Buffer(),
+    Scope.method = (name, method) => {
+        return Scope.property(name,{
+            value: method,
             writable: false,
             configurable: false,
             enumerable: false
-        },
-        // [BLOCKS]: {
-        //     value: {},
-        //     writable: true,
-        //     configurable: false,
-        //     enumerable: false
-        // },
-        // [EXTEND]: {
-        //     value: false,
-        //     writable: true,
-        //     configurable: false,
-        //     enumerable: false
-        // },
-        // [LAYOUT]: {
-        //     value: false,
-        //     writable: true,
-        //     configurable: false,
-        //     enumerable: false
-        // },
-        // setBuffer: {
-        //     value(value) {
-        //         this[BUFFER] = value
-        //     },
-        //     writable: false,
-        //     configurable: false
-        // },
-        getBuffer: {
-            value() {
-                return this[BUFFER]
-            },
-            writable: false,
-            configurable: false
-        },
-        setBlocks: {
-            value(value) {
-                this[BLOCKS] = value;
-            },
-            writable: false,
-            configurable: false
-        },
-        getBlocks: {
-            value() {
-                return this[BLOCKS]
-            },
-            writable: false,
-            configurable: false
-        },
-        setExtend: {
-            value(value) {
-                this[EXTEND] = value;
-            },
-            writable: false,
-            configurable: false
-        },
-        getExtend: {
-            value() {
-                return this[EXTEND]
-            },
-            writable: false,
-            configurable: false
-        },
-        setLayout: {
-            value(layout) {
-                this[LAYOUT] = layout;
-            },
-            writable: false,
-            configurable: false
-        },
-        getLayout: {
-            value() {
-                return this[LAYOUT]
-            },
-            writable: false,
-            configurable: false
+        })
+    };
+    /**
+     *
+     */
+    Scope.property(BUFFER, {
+        value: Buffer(),
+        writable: false,
+        configurable: false,
+        enumerable: false
+    });
+    /**
+     *
+     */
+    Scope.property(BLOCKS, {
+        value: {},
+        writable: true,
+        configurable: false,
+        enumerable: false
+    });
+    /**
+     *
+     */
+    Scope.property(MACRO, {
+        value: {},
+        writable: true,
+        configurable: false,
+        enumerable: false
+    });
+    /**
+     *
+     */
+    Scope.property(LAYOUT, {
+        value: false,
+        writable: true,
+        configurable: false,
+        enumerable: false
+    });
+    /**
+     *
+     */
+    Scope.property(EXTEND, {
+        value: false,
+        writable: true,
+        configurable: false,
+        enumerable: false
+    });
+    /**
+     *
+     */
+    Scope.method('initBlocks', function() {
+        this[BLOCKS] = {};
+    });
+    /**
+     *
+     */
+    Scope.method('initMacro', function() {
+        this[MACRO] = {};
+    });
+    /**
+     *
+     */
+    Scope.method('getMacro', function() {
+        return this[MACRO]
+    });
+    /**
+     *
+     */
+    Scope.method('getBuffer', function() {
+        return this[BUFFER]
+    });
+    /**
+     *
+     */
+    Scope.method('getBlocks', function() {
+        return this[BLOCKS]
+    });
+    /**
+     *
+     */
+    Scope.method('setExtend', function(value) {
+        this[EXTEND] = value;
+    });
+    /**
+     *
+     */
+    Scope.method('getExtend', function() {
+        return this[EXTEND]
+    });
+    /**
+     *
+     */
+    Scope.method('setLayout', function(layout) {
+        this[LAYOUT] = layout;
+    });
+    /**
+     *
+     */
+    Scope.method('getLayout', function() {
+        return this[LAYOUT]
+    });
+    /**
+     *
+     */
+    Scope.method('clone', function(exclude_blocks) {
+        const filter = [LAYOUT, EXTEND, BUFFER];
+        if (exclude_blocks === true) {
+            filter.push(BLOCKS);
         }
+        return omit(this, filter)
     });
-
-    Scope.helpers = (methods) => {
-        extend(Scope.prototype, methods);
-    };
-
     /**
-     * @lends Scope.prototype
+     * @methodOf global
+     * @function extend
+     * @param layout
      */
-    Scope.helpers(methods);
+    Scope.method('extend', function(layout) {
+        this.setExtend(true);
+        this.setLayout(layout);
+    });
     /**
-     * @lends Scope.prototype
+     * @memberOf global
+     * @function echo
      */
-    Scope.helpers({
-        /**
-         * @return {*}
-         */
-        clone(exclude_blocks) {
-            const filter = [LAYOUT, EXTEND, MACROS, BUFFER];
-            if (exclude_blocks === true) {
-                filter.push(BLOCKS);
+    Scope.method('echo', function() {
+        const buffer = this.getBuffer();
+        const params = [].slice.call(arguments);
+        params.forEach(function(item) {
+            buffer(item);
+        });
+    });
+    /**
+     * @memberOf global
+     * @function fn
+     * @param callback
+     */
+    Scope.method('fn', function(callback) {
+        const buffer = this.getBuffer();
+        const context = this;
+        return function() {
+            buffer.backup();
+            if (isFunction(callback)) {
+                callback.apply(context, arguments);
             }
-            return omit(this, filter)
-        },
-        /**
-         * Join values to output buffer
-         * @memberOf global
-         * @type Function
-         */
-        echo() {
-            const buffer = this.getBuffer();
-            const params = [].slice.call(arguments);
-            params.forEach(function(item) {
-                buffer(item);
-            });
-        },
-        /**
-         * Buffered output callback
-         * @type Function
-         * @param {Function} callback
-         * @param {Boolean} [echo]
-         * @return {Function}
-         */
-        macro(callback, echo) {
-            const buffer = this.getBuffer();
-            const macro = function() {
-                buffer.backup();
-                if (isFunction(callback)) {
-                    callback.apply(this, arguments);
+            return buffer.restore()
+        }
+    });
+    /**
+     * @memberOf global
+     * @function get
+     * @param name
+     * @param [defaults]
+     */
+    Scope.method('get', function(name,defaults) {
+        const path = getPath(this, name);
+        const result = path.shift();
+        const prop = path.pop();
+        return hasProp(result, prop) ? result[prop] : defaults
+    });
+    /**
+     * @memberOf global
+     * @function set
+     * @param name
+     * @param value
+     */
+    Scope.method('set', function(name,value) {
+        const path = getPath(this, name);
+        const result = path.shift();
+        const prop = path.pop();
+        if (this.getExtend() && hasProp(result, prop)) {
+            return result[prop]
+        }
+        return result[prop] = value
+    });
+    /**
+     * @memberOf global
+     * @function macro
+     * @param name
+     * @param callback
+     */
+    Scope.method('macro', function(name, callback) {
+        const list = this.getMacro();
+        const macro = this.fn(callback);
+        const context = this;
+        list[name] = function() {
+            return context.echo(macro.apply(undefined, arguments))
+        };
+    });
+    /**
+     * @memberOf global
+     * @function call
+     * @param name
+     * @param {...*} args
+     */
+    Scope.method('call', function(name) {
+        const list = this.getMacro();
+        const macro = list[name];
+        const params = [].slice.call(arguments, 1);
+        if (isFunction(macro)) {
+            return macro.apply(macro, params)
+        }
+    });
+    /**
+     * @memberOf global
+     * @function block
+     * @param name
+     * @param callback
+     */
+    Scope.method('block',function(name,callback){
+        const blocks = this.getBlocks();
+        blocks[name] = blocks[name] || [];
+        blocks[name].push(this.fn(callback));
+        if (this.getExtend()) return
+        const list = Object.assign([], blocks[name]);
+        const current = function() {
+            return list.shift()
+        };
+        const next = () => {
+            const parent = current();
+            if (parent) {
+                return () => {
+                    this.echo(parent(next()));
                 }
-                const result = buffer.restore();
-                return echo === true ? this.echo(result) : result
-            }.bind(this);
-            macro.__context = this;
-            macro.__source = callback;
-            macro.__layout = this.getLayout();
-            return macro
-        },
-        /**
-         * @memberOf global
-         * @param value
-         * @param callback
-         * @return {Promise<unknown>}
-         */
-        resolve(value, callback) {
-            return Promise.resolve(value).then(callback.bind(this))
-        },
-        /**
-         * @memberOf global
-         */
-        async(promise, callback) {
-            this.echo(
-                this.resolve(promise, (data) => this.macro(callback)(data))
-            );
-        },
-        /**
-         * @memberOf global
-         */
-        node: element,
+            } else {
+                return noop
+            }
+        };
+        this.echo(current()(next()));
+    });
+    /**
+     *  @memberOf global
+     *  @function include
+     *  @param path
+     *  @param [data]
+     *  @param [cx]
+     */
+    Scope.method('include',function(path, data, cx){
+        const context = cx === false ? {} : this.clone(true);
+        const params = extend(context, data || {});
+        const promise = this.render(path, params);
+        this.echo(promise);
+    });
+    /**
+     * @memberOf global
+     * @function use
+     * @param path
+     * @param namespace
+     */
+    Scope.method('use',function(path, namespace){
+        const promise = this.require(path);
+        this.echo(resolve$1(promise,function(exports){
+            const list = this.getMacro();
+            each(exports, function(macro, name) {
+                list[[namespace, name].join('.')] = macro;
+            });
+        },this));
+    });
+    /**
+     *  @memberOf global
+     *  @function async
+     *  @param promise
+     *  @param callback
+     */
+    Scope.method('async',function(promise,callback){
+        this.echo(
+            resolve$1(promise, function(data) {
+                return this.fn(callback)(data)
+            }, this)
+        );
+    });
+    Scope.helpers(methods);
+    Scope.helpers({
         /**
          * @memberOf global
+         * @param tag
+         * @param attr
+         * @param content
          */
-        element(tag, attr, content) {
+        el(tag, attr, content) {
             if (isFunction(content)) {
-                content = this.macro(content)();
+                content = this.fn(content)();
             }
             this.echo(
-                this.resolve(content, (content) => element(tag, attr, content))
-            );
-        },
-        /**
-         * @memberOf global
-         * @param {String} namespace
-         * @param {Object} instance
-         */
-        component(namespace, instance) {
-            instance = Component(instance);
-            this.set(
-                namespace,
-                function(props) {
-                    this.echo(instance.render(props));
-                }.bind(this)
+                resolve$1(content, function(content) {
+                    return element(tag, attr, content)
+                }, this)
             );
         },
-        /**
-         * @memberOf global
-         * @param name
-         * @param defaults
-         */
-        get(name, defaults) {
-            const path = getPath(this, name);
-            const result = path.shift();
-            const prop = path.pop();
-            return hasProp(result, prop) ? result[prop] : defaults
-        },
-        /**
-         * @memberOf global
-         * @param {String} name
-         * @param value
-         * @return
-         */
-        set(name, value) {
-            const path = getPath(this, name);
-            const result = path.shift();
-            const prop = path.pop();
-            if (this.getExtend()) {
-                if (hasProp(result, prop)) {
-                    return result[prop]
-                }
-            }
-            result[prop] = value;
-        },
-        /**
-         * @memberOf global
-         * @param name
-         */
-        call(name) {
-            const params = [].slice.call(arguments, 1);
-            const path = getPath(this, name);
-            const result = path.shift();
-            const prop = path.pop();
-            if (isFunction(result[prop])) {
-                return result[prop].apply(result, params)
-            }
-        },
         /**
          * @memberOf global
          * @param object
@@ -696,89 +763,6 @@ const Scope = (config, methods) => {
                 object = this.get(object, []);
             }
             each(object, callback);
-        },
-        /**
-         * @memberOf global
-         * @param {String} layout
-         */
-        extend(layout) {
-            this.setExtend(true);
-            this.setLayout(layout);
-        },
-        /**
-         * @memberOf global
-         * @param name
-         * @param callback
-         * @return {*}
-         */
-        block(name, callback) {
-            const blocks = this.getBlocks();
-            blocks[name] = blocks[name] || [];
-            blocks[name].push(this.macro(callback));
-            if (this.getExtend() === false) {
-                const list = blocks[name];
-                const callback = function(){
-                    const parent = list.shift();
-                    if( parent ) {
-                        const context = parent.__context;
-                        return function(){
-                            context.echo(parent(callback()));
-                        }
-                    } else {
-                        return function(){}
-                    }
-                };
-                this.echo(list.shift()(callback()));
-            }
-        },
-        /**
-         * @memberOf global
-         * @param {string} path
-         * @param {object} [data]
-         * @param {boolean} [cx]
-         */
-        include(path, data, cx) {
-            const context = cx === false ? {} : this.clone(true);
-            const params = extend(context, data || {});
-            const promise = this.render(path, params);
-            this.echo(promise);
-        },
-        /**
-         * @memberOf global
-         * @param {string} path
-         */
-        use(path) {
-            const scope = this;
-            const promise = this.require(path);
-            this.echo(promise);
-            return {
-                as(namespace) {
-                    promise.then((exports) => {
-                        scope.set(namespace, exports);
-                    });
-                    return this
-                }
-            }
-        },
-        /**
-         * @memberOf global
-         * @param {string} path
-         */
-        from(path) {
-            const scope = this;
-            const promise = this.require(path);
-            this.echo(promise);
-            return {
-                use() {
-                    const params = [].slice.call(arguments);
-                    promise.then((exports) => {
-                        params.forEach((name) => {
-                            scope.set(name, exports[name]);
-                        });
-                    });
-                    return this
-                }
-            }
         }
     });
     return Scope
@@ -839,7 +823,7 @@ function init(options) {
             })
         },
         render(name, data) {
-            const filepath = ext(name, config.extension.template);
+            const filepath = ext(name, config.extension);
             const scope = new view.scope(data);
             return view.output(filepath, scope).then((content) => {
                 if (scope.getExtend()) {
@@ -852,10 +836,10 @@ function init(options) {
             })
         },
         require(name) {
-            const filepath = ext(name, config.extension.module);
+            const filepath = ext(name, config.extension);
             const scope = new view.scope({});
             return view.output(filepath, scope).then(() => {
-                return scope.clone(true)
+                return scope.getMacro()
             })
         },
         helpers(methods) {
@@ -871,10 +855,14 @@ function init(options) {
                 defaults.resolver,
                 options.resolver
             );
-            config.extension = extend({}, defaults.extension, options.extension);
+            config.extension = typeProp(
+                isString,
+                defaults.extension,
+                options.extension
+            );
             config.token = extend({}, defaults.token, options.token);
             config.vars = extend({}, defaults.vars, options.vars);
-            view.scope = Scope(config, helpers);
+            view.scope = configure(config, helpers);
             view.compile = Compiler(config);
             view.wrapper = Wrapper(config);
             view.cache = Cache(config);