@kosatyi/ejs 0.0.100 → 0.0.102

package/dist/esm/worker.js

@@ -409,7 +409,7 @@ class Compiler {
         source = `${BUFFER}.start();${source}return ${BUFFER}.end();`;
         source += `\n//# sourceURL=${path}`;
         let result = null;
-        let params = [SCOPE, BUFFER, SAFE, COMPONENT, ELEMENT].concat(GLOBALS);
+        let params = [SCOPE, COMPONENT, ELEMENT, BUFFER, SAFE].concat(GLOBALS);
         try {
             result = Function.apply(null, params.concat(source));
             result.source = `(function(${params.join(',')}){\n${source}\n});`;
@@ -577,6 +577,8 @@ function createBuffer() {
     return buffer
 }
 
+const PARENT = Symbol('ContextScope.parentTemplate');
+
 const createContextScope = (config, methods) => {
     const {
         BLOCKS,
@@ -587,14 +589,20 @@ const createContextScope = (config, methods) => {
         SAFE,
         SCOPE,
         COMPONENT,
-        ELEMENT,
+        ELEMENT
     } = config.vars;
+    /**
+     *
+     * @type {symbol}
+     */
+
     /**
      * @name ContextScope
      * @param data
      * @constructor
      */
     function ContextScope(data) {
+        this[PARENT] = null;
         this[BLOCKS] = {};
         this[MACRO] = {};
         Object.assign(
@@ -604,28 +612,45 @@ const createContextScope = (config, methods) => {
     }
     Object.assign(ContextScope.prototype, methods);
     Object.defineProperty(ContextScope.prototype, BUFFER, {
-        value: createBuffer(),
+        value: createBuffer()
     });
     Object.defineProperty(ContextScope.prototype, BLOCKS, {
         value: {},
-        writable: true,
+        writable: true
     });
     Object.defineProperty(ContextScope.prototype, MACRO, {
         value: {},
-        writable: true,
+        writable: true
     });
     Object.defineProperty(ContextScope.prototype, LAYOUT, {
         value: false,
-        writable: true,
+        writable: true
     });
     Object.defineProperty(ContextScope.prototype, EXTEND, {
         value: false,
-        writable: true,
+        writable: true
+    });
+    Object.defineProperty(ContextScope.prototype, PARENT, {
+        value: null,
+        writable: true
     });
     Object.defineProperties(ContextScope.prototype, {
+        /** @type {function} */
+        setParentTemplate:{
+            value(value){
+                this[PARENT] = value;
+                return this
+            }
+        },
+        /** @type {function} */
+        getParentTemplate: {
+            value(){
+                return this[PARENT]
+            }
+        },
         /** @type {function} */
         useSafeValue: {
-            get: () => safeValue,
+            get: () => safeValue
         },
         /** @type {function} */
         useComponent: {
@@ -637,7 +662,7 @@ const createContextScope = (config, methods) => {
                         throw new Error(`${COMPONENT} must be a function`)
                     }
                 }
-            },
+            }
         },
         /** @type {function} */
         useElement: {
@@ -649,49 +674,51 @@ const createContextScope = (config, methods) => {
                         throw new Error(`${ELEMENT} must be a function`)
                     }
                 }
-            },
+            }
         },
         /** @type {()=>this[MACRO]} */
         getMacro: {
             value() {
                 return this[MACRO]
-            },
+            }
         },
         /** @type {function} */
         getBuffer: {
             value() {
                 return this[BUFFER]
-            },
+            }
         },
         /** @type {function} */
         getBlocks: {
             value() {
                 return this[BLOCKS]
-            },
+            }
         },
         /** @type {function} */
         setExtend: {
             value(value) {
                 this[EXTEND] = value;
-            },
+                return this
+            }
         },
         /** @type {function} */
         getExtend: {
             value() {
                 return this[EXTEND]
-            },
+            }
         },
         /** @type {function} */
         setLayout: {
             value(layout) {
                 this[LAYOUT] = layout;
-            },
+                return this
+            }
         },
         /** @type {function} */
         getLayout: {
             value() {
                 return this[LAYOUT]
-            },
+            }
         },
         /** @type {function} */
         clone: {
@@ -701,14 +728,14 @@ const createContextScope = (config, methods) => {
                     filter.push(BLOCKS);
                 }
                 return omit(this, filter)
-            },
+            }
         },
         /** @type {function} */
         extend: {
             value(layout) {
                 this.setExtend(true);
                 this.setLayout(layout);
-            },
+            }
         },
         /** @type {function} */
         echo: {
@@ -716,21 +743,21 @@ const createContextScope = (config, methods) => {
                 const buffer = this.getBuffer();
                 const params = [].slice.call(arguments);
                 params.forEach(buffer);
-            },
+            }
         },
         /** @type {function} */
         fn: {
             value(callback) {
                 const buffer = this.getBuffer();
                 const context = this;
-                return function () {
+                return function() {
                     if (isFunction(callback)) {
                         buffer.backup();
                         buffer(callback.apply(context, arguments));
                         return buffer.restore()
                     }
                 }
-            },
+            }
         },
         /** @type {function} */
         macro: {
@@ -738,10 +765,10 @@ const createContextScope = (config, methods) => {
                 const list = this.getMacro();
                 const macro = this.fn(callback);
                 const context = this;
-                list[name] = function () {
+                list[name] = function() {
                     return context.echo(macro.apply(undefined, arguments))
                 };
-            },
+            }
         },
         /** @type {function} */
         call: {
@@ -752,7 +779,7 @@ const createContextScope = (config, methods) => {
                 if (isFunction(macro)) {
                     return macro.apply(macro, params)
                 }
-            },
+            }
         },
         /** @type {function} */
         block: {
@@ -776,13 +803,13 @@ const createContextScope = (config, methods) => {
                     }
                 };
                 this.echo(current()(next()));
-            },
+            }
         },
         /** @type {function} */
         hasBlock: {
             value(name) {
                 return this.getBlocks().hasOwnProperty(name)
-            },
+            }
         },
         /** @type {function} */
         include: {
@@ -791,7 +818,7 @@ const createContextScope = (config, methods) => {
                 const params = extend(context, data || {});
                 const promise = this.render(path, params);
                 this.echo(promise);
-            },
+            }
         },
         /** @type {function} */
         use: {
@@ -799,18 +826,18 @@ const createContextScope = (config, methods) => {
                 this.echo(
                     Promise.resolve(this.require(path)).then((exports) => {
                         const list = this.getMacro();
-                        each(exports, function (macro, name) {
+                        each(exports, function(macro, name) {
                             list[[namespace, name].join('.')] = macro;
                         });
                     })
                 );
-            },
+            }
         },
         /** @type {function} */
         async: {
             value(promise, callback) {
                 this.echo(Promise.resolve(promise).then(callback));
-            },
+            }
         },
         /** @type {function} */
         get: {
@@ -819,29 +846,29 @@ const createContextScope = (config, methods) => {
                 const result = path.shift();
                 const prop = path.pop();
                 return hasProp(result, prop) ? result[prop] : defaults
-            },
+            }
         },
         /** @type {function} */
         set: {
             value(name, value) {
                 const path = getPath(this, name, false);
-                const result = path.shift();
+                const result= path.shift();
                 const prop = path.pop();
-                if (this.getExtend() && hasProp(result, prop)) {
+                if (this.getParentTemplate() && hasProp(result, prop)) {
                     return result[prop]
                 }
                 return (result[prop] = value)
-            },
+            }
         },
         /** @type {function} */
         each: {
-            value: function (object, callback) {
+            value: function(object, callback) {
                 if (isString(object)) {
                     object = this.get(object, []);
                 }
                 each(object, callback);
             },
-            writable: true,
+            writable: true
         },
         /** @type {function} */
         el: {
@@ -853,28 +880,33 @@ const createContextScope = (config, methods) => {
                     )
                 );
             },
-            writable: true,
+            writable: true
         },
         /** @type {function} */
         ui: {
-            value(layout) {},
-            writable: true,
-        },
+            value(layout) {
+            },
+            writable: true
+        }
     });
     return ContextScope
 };
 
 class Context {
     #scope
+
     constructor(config, methods) {
         this.configure(config, methods);
     }
+
     create(data) {
         return new this.#scope(data)
     }
+
     configure(config, methods) {
         this.#scope = createContextScope(config, methods);
     }
+
     helpers(methods) {
         extend(this.#scope.prototype, methods || {});
     }
@@ -887,6 +919,7 @@ class EJS {
     #compiler
     #cache
     #template
+
     constructor(options) {
         configSchema(this.#config, options || {});
         this.#context = new Context(this.#config, this.#extend);
@@ -894,19 +927,11 @@ class EJS {
         this.#cache = new Cache(this.#config);
         this.#template = new Template(this.#config, this.#cache, this.#compiler);
         //
-        bindContext(this, [
-            'configure',
-            'create',
-            'render',
-            'require',
-            'context',
-            'preload',
-            'compile',
-            'helpers',
-        ]);
+        bindContext(this, ['configure', 'create', 'render', 'require', 'context', 'preload', 'compile', 'helpers']);
         //
         this.helpers({ require: this.require, render: this.render });
     }
+
     configure(options) {
         configSchema(this.#config, options || {});
         this.#context.configure(this.#config, this.#extend);
@@ -915,55 +940,66 @@ class EJS {
         this.#template.configure(this.#config);
         return this.#config
     }
+
+    filePath(name) {
+        return ext(name, this.#config.extension)
+    }
+
+    require(name) {
+        const scope = this.context({});
+        return this.#output(this.filePath(name), scope).then(() => scope.getMacro())
+    }
+
     render(name, data) {
-        const filepath = ext(name, this.#config.extension);
         const scope = this.context(data);
-        return this.#output(filepath, scope).then((content) => {
+        return this.#output(this.filePath(name), scope).then(this.outputContent(name, scope))
+    }
+
+    outputContent(name, scope) {
+        return (content) => {
             if (scope.getExtend()) {
                 scope.setExtend(false);
-                const layout = scope.getLayout();
-                const data = scope.clone();
-                return this.render(layout, data)
+                return this.renderLayout(scope.getLayout(), scope, name)
             }
             return content
-        })
+        }
+    }
+
+    renderLayout(name, data, parent) {
+        const scope = this.context(data);
+        if (parent) scope.setParentTemplate(parent);
+        return this.#output(this.filePath(name), scope).then(this.outputContent(name, scope))
     }
+
     helpers(methods) {
         this.#context.helpers(extend(this.#extend, methods));
     }
+
     context(data) {
         return this.#context.create(data)
     }
+
     compile(content, path) {
         return this.#compiler.compile(content, path)
     }
+
     preload(list) {
         return this.#cache.load(list || {})
     }
+
     create(options) {
         return new this.constructor(options)
     }
-    require(name) {
-        const filepath = ext(name, this.#config.extension);
-        const scope = this.context({});
-        return this.#output(filepath, scope).then(() => scope.getMacro())
-    }
+
     #output(path, scope) {
         const { globalHelpers } = this.#config;
-        const params = [
-            scope,
-            scope.getBuffer(),
-            scope.useSafeValue,
-            scope.useComponent,
-            scope.useElement,
-        ].concat(
-            globalHelpers
-                .filter((name) => isFunction(scope[name]))
-                .map((name) => scope[name].bind(scope))
-        );
+        const params = [scope, scope.useComponent, scope.useElement, scope.getBuffer(), scope.useSafeValue];
+        const globals = globalHelpers
+            .filter((name) => isFunction(scope[name]))
+            .map((name) => scope[name].bind(scope));
         return this.#template
             .get(path)
-            .then((callback) => callback.apply(scope, params))
+            .then((callback) => callback.apply(scope, params.concat(globals)))
     }
 }
 

package/dist/umd/browser.js

@@ -513,7 +513,7 @@
         source = "".concat(BUFFER, ".start();").concat(source, "return ").concat(BUFFER, ".end();");
         source += "\n//# sourceURL=".concat(path);
         var result = null;
-        var params = [SCOPE, BUFFER, SAFE, COMPONENT, ELEMENT].concat(GLOBALS);
+        var params = [SCOPE, COMPONENT, ELEMENT, BUFFER, SAFE].concat(GLOBALS);
         try {
           result = Function.apply(null, params.concat(source));
           result.source = "(function(".concat(params.join(','), "){\n").concat(source, "\n});");
@@ -705,6 +705,7 @@
     return buffer;
   }
 
+  var PARENT = Symbol('ContextScope.parentTemplate');
   var createContextScope = function createContextScope(config, methods) {
     var _config$vars = config.vars,
       BLOCKS = _config$vars.BLOCKS,
@@ -716,12 +717,18 @@
       SCOPE = _config$vars.SCOPE,
       COMPONENT = _config$vars.COMPONENT,
       ELEMENT = _config$vars.ELEMENT;
+    /**
+     *
+     * @type {symbol}
+     */
+
     /**
      * @name ContextScope
      * @param data
      * @constructor
      */
     function ContextScope(data) {
+      this[PARENT] = null;
       this[BLOCKS] = {};
       this[MACRO] = {};
       Object.assign(this, omit(data, [SCOPE, BUFFER, SAFE, COMPONENT, ELEMENT]));
@@ -746,7 +753,24 @@
       value: false,
       writable: true
     });
+    Object.defineProperty(ContextScope.prototype, PARENT, {
+      value: null,
+      writable: true
+    });
     Object.defineProperties(ContextScope.prototype, {
+      /** @type {function} */
+      setParentTemplate: {
+        value: function value(_value) {
+          this[PARENT] = _value;
+          return this;
+        }
+      },
+      /** @type {function} */
+      getParentTemplate: {
+        value: function value() {
+          return this[PARENT];
+        }
+      },
       /** @type {function} */
       useSafeValue: {
         get: function get() {
@@ -797,8 +821,9 @@
       },
       /** @type {function} */
       setExtend: {
-        value: function value(_value) {
-          this[EXTEND] = _value;
+        value: function value(_value2) {
+          this[EXTEND] = _value2;
+          return this;
         }
       },
       /** @type {function} */
@@ -811,6 +836,7 @@
       setLayout: {
         value: function value(layout) {
           this[LAYOUT] = layout;
+          return this;
         }
       },
       /** @type {function} */
@@ -949,14 +975,14 @@
       },
       /** @type {function} */
       set: {
-        value: function value(name, _value2) {
+        value: function value(name, _value3) {
           var path = getPath(this, name, false);
           var result = path.shift();
           var prop = path.pop();
-          if (this.getExtend() && hasProp(result, prop)) {
+          if (this.getParentTemplate() && hasProp(result, prop)) {
             return result[prop];
           }
-          return result[prop] = _value2;
+          return result[prop] = _value3;
         }
       },
       /** @type {function} */
@@ -1052,21 +1078,43 @@
         _classPrivateFieldGet2(_template, this).configure(_classPrivateFieldGet2(_config, this));
         return _classPrivateFieldGet2(_config, this);
       }
+    }, {
+      key: "filePath",
+      value: function filePath(name) {
+        return ext(name, _classPrivateFieldGet2(_config, this).extension);
+      }
+    }, {
+      key: "require",
+      value: function require(name) {
+        var scope = this.context({});
+        return _assertClassBrand(_EJS_brand, this, _output).call(this, this.filePath(name), scope).then(function () {
+          return scope.getMacro();
+        });
+      }
     }, {
       key: "render",
       value: function render(name, data) {
-        var _this = this;
-        var filepath = ext(name, _classPrivateFieldGet2(_config, this).extension);
         var scope = this.context(data);
-        return _assertClassBrand(_EJS_brand, this, _output).call(this, filepath, scope).then(function (content) {
+        return _assertClassBrand(_EJS_brand, this, _output).call(this, this.filePath(name), scope).then(this.outputContent(name, scope));
+      }
+    }, {
+      key: "outputContent",
+      value: function outputContent(name, scope) {
+        var _this = this;
+        return function (content) {
           if (scope.getExtend()) {
             scope.setExtend(false);
-            var layout = scope.getLayout();
-            var _data = scope.clone();
-            return _this.render(layout, _data);
+            return _this.renderLayout(scope.getLayout(), scope, name);
           }
           return content;
-        });
+        };
+      }
+    }, {
+      key: "renderLayout",
+      value: function renderLayout(name, data, parent) {
+        var scope = this.context(data);
+        if (parent) scope.setParentTemplate(parent);
+        return _assertClassBrand(_EJS_brand, this, _output).call(this, this.filePath(name), scope).then(this.outputContent(name, scope));
       }
     }, {
       key: "helpers",
@@ -1093,27 +1141,19 @@
       value: function create(options) {
         return new this.constructor(options);
       }
-    }, {
-      key: "require",
-      value: function require(name) {
-        var filepath = ext(name, _classPrivateFieldGet2(_config, this).extension);
-        var scope = this.context({});
-        return _assertClassBrand(_EJS_brand, this, _output).call(this, filepath, scope).then(function () {
-          return scope.getMacro();
-        });
-      }
     }]);
   }();
   function _output(path, scope) {
     var _classPrivateFieldGet2$1 = _classPrivateFieldGet2(_config, this),
       globalHelpers = _classPrivateFieldGet2$1.globalHelpers;
-    var params = [scope, scope.getBuffer(), scope.useSafeValue, scope.useComponent, scope.useElement].concat(globalHelpers.filter(function (name) {
+    var params = [scope, scope.useComponent, scope.useElement, scope.getBuffer(), scope.useSafeValue];
+    var globals = globalHelpers.filter(function (name) {
       return isFunction(scope[name]);
     }).map(function (name) {
       return scope[name].bind(scope);
-    }));
+    });
     return _classPrivateFieldGet2(_template, this).get(path).then(function (callback) {
-      return callback.apply(scope, params);
+      return callback.apply(scope, params.concat(globals));
     });
   }