@kosatyi/ejs 0.0.100 → 0.0.102

package/dist/esm/browser.js

@@ -415,7 +415,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});`;
@@ -583,6 +583,8 @@ function createBuffer() {
     return buffer
 }
 
+const PARENT = Symbol('ContextScope.parentTemplate');
+
 const createContextScope = (config, methods) => {
     const {
         BLOCKS,
@@ -593,14 +595,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(
@@ -610,28 +618,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: {
@@ -643,7 +668,7 @@ const createContextScope = (config, methods) => {
                         throw new Error(`${COMPONENT} must be a function`)
                     }
                 }
-            },
+            }
         },
         /** @type {function} */
         useElement: {
@@ -655,49 +680,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: {
@@ -707,14 +734,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: {
@@ -722,21 +749,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: {
@@ -744,10 +771,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: {
@@ -758,7 +785,7 @@ const createContextScope = (config, methods) => {
                 if (isFunction(macro)) {
                     return macro.apply(macro, params)
                 }
-            },
+            }
         },
         /** @type {function} */
         block: {
@@ -782,13 +809,13 @@ const createContextScope = (config, methods) => {
                     }
                 };
                 this.echo(current()(next()));
-            },
+            }
         },
         /** @type {function} */
         hasBlock: {
             value(name) {
                 return this.getBlocks().hasOwnProperty(name)
-            },
+            }
         },
         /** @type {function} */
         include: {
@@ -797,7 +824,7 @@ const createContextScope = (config, methods) => {
                 const params = extend(context, data || {});
                 const promise = this.render(path, params);
                 this.echo(promise);
-            },
+            }
         },
         /** @type {function} */
         use: {
@@ -805,18 +832,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: {
@@ -825,29 +852,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: {
@@ -859,28 +886,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 || {});
     }
@@ -893,6 +925,7 @@ class EJS {
     #compiler
     #cache
     #template
+
     constructor(options) {
         configSchema(this.#config, options || {});
         this.#context = new Context(this.#config, this.#extend);
@@ -900,19 +933,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);
@@ -921,55 +946,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)))
     }
 }