@kosatyi/ejs 0.0.65 → 0.0.66

package/dist/esm/index.js

@@ -95,8 +95,10 @@ const ext = (path, defaults) => {
     return path
 };
 
-const extend = (...args) => {
-    const target = args.shift();
+/**
+ * @type {<T extends {}, U, V, W,Y>(T,U,V,W,Y)=> T & U & V & W & Y}
+ */
+const extend = (target, ...args) => {
     return args
         .filter((source) => source)
         .reduce((target, source) => Object.assign(target, source), target)
@@ -506,7 +508,7 @@ function resolve(list) {
     return Promise.all(list || []).then((list) => list.join(''))
 }
 
-const createBuffer = function () {
+function createBuffer() {
     let store = [],
         array = [];
     function buffer(value) {
@@ -531,11 +533,10 @@ const createBuffer = function () {
         return resolve(array)
     };
     return buffer
-};
+}
 
 function Context(config) {
     if (instanceOf(this, Context) === false) return new Context(config)
-
     this.configure = function (config, methods) {
         const { BLOCKS, MACRO, EXTEND, LAYOUT, BUFFER, COMPONENT } = config.vars;
 
@@ -545,6 +546,7 @@ function Context(config) {
 
         this.helpers = function (methods) {
             extend(Scope.prototype, methods || {});
+            console.log('helpers', Scope.prototype);
         };
 
         function Scope(data) {
@@ -552,218 +554,319 @@ function Context(config) {
             this[MACRO] = {};
             extend(this, data || {});
         }
-        Scope.prototype = extend({}, methods || {});
-        Scope.method = Scope.define = function (
-            name,
-            value,
-            writable,
-            configurable,
-            enumerable
-        ) {
-            Object.defineProperty(Scope.prototype, name, {
-                value: value,
-                writable: writable || false,
-                configurable: configurable || false,
-                enumerable: enumerable || false,
-            });
-        };
-
-        Scope.define(BUFFER, createBuffer());
-        Scope.define(BLOCKS, {}, true);
-        Scope.define(MACRO, {}, true);
-        Scope.define(LAYOUT, false, true);
-        Scope.define(EXTEND, false, true);
-
-        Scope.method('getMacro', function () {
-            return this[MACRO]
-        });
-
-        Scope.method('getBuffer', function () {
-            return this[BUFFER]
-        });
-
-        Scope.method('getComponent', function () {
-            const context = this;
-            if (COMPONENT in context) {
-                return function () {
-                    return context[COMPONENT].apply(context, arguments)
-                }
-            }
-            return function () {
-                console.log('%s function not defined', COMPONENT);
-            }
-        });
-
-        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.method('extend', function (layout) {
-            this.setExtend(true);
-            this.setLayout(layout);
-        });
-
-        Scope.method('echo', function () {
-            const buffer = this.getBuffer();
-            const params = [].slice.call(arguments);
-            params.forEach(buffer);
-        });
-
-        Scope.method('fn', function (callback) {
-            const buffer = this.getBuffer();
-            const context = this;
-            return function () {
-                buffer.backup();
-                if (isFunction(callback)) {
-                    callback.apply(context, arguments);
-                }
-                return buffer.restore()
-            }
-        });
-
-        Scope.method('get', function (name, defaults) {
-            const path = getPath(this, name, true);
-            const result = path.shift();
-            const prop = path.pop();
-            return hasProp(result, prop) ? result[prop] : defaults
-        });
-
-        Scope.method('set', function (name, value) {
-            const path = getPath(this, name, false);
-            const result = path.shift();
-            const prop = path.pop();
-            if (this.getExtend() && hasProp(result, prop)) {
-                return result[prop]
-            }
-            return (result[prop] = value)
-        });
 
-        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))
-            };
-        });
-
-        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)
-            }
-        });
-
-        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()));
+        Scope.prototype = extend({}, methods || {});
+        Object.defineProperties(Scope.prototype, {
+            [BUFFER]: {
+                value: createBuffer(),
+                writable: true,
+                configurable: false,
+                enumerable: false,
+            },
+            [BLOCKS]: {
+                value: {},
+                writable: true,
+                configurable: false,
+                enumerable: false,
+            },
+            [MACRO]: {
+                value: {},
+                writable: true,
+                configurable: false,
+                enumerable: false,
+            },
+            [LAYOUT]: {
+                value: false,
+                writable: true,
+                configurable: false,
+                enumerable: false,
+            },
+            [EXTEND]: {
+                value: false,
+                writable: true,
+                configurable: false,
+                enumerable: false,
+            },
+            getMacro: {
+                value() {
+                    return this[MACRO]
+                },
+                writable: false,
+                configurable: false,
+                enumerable: false,
+            },
+            getBuffer: {
+                value() {
+                    return this[BUFFER]
+                },
+                writable: false,
+                configurable: false,
+                enumerable: false,
+            },
+            getComponent: {
+                value() {
+                    const context = this;
+                    if (COMPONENT in context) {
+                        return function () {
+                            return context[COMPONENT].apply(context, arguments)
+                        }
                     }
-                } else {
-                    return noop
-                }
-            };
-            this.echo(current()(next()));
-        });
-
-        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);
-        });
-
-        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
-                )
-            );
-        });
-
-        Scope.method('async', function (promise, callback) {
-            this.echo(
-                resolve$1(
-                    promise,
-                    function (data) {
-                        return this.fn(callback)(data)
-                    },
-                    this
-                )
-            );
-        });
-
-        Scope.method('node', function (tag, attr, content) {
-            return element(tag, attr, content)
-        });
-
-        Scope.method('el', function (tag, attr, content) {
-            if (isFunction(content)) {
-                content = this.fn(content)();
-            }
-            this.echo(
-                resolve$1(
-                    content,
-                    function (content) {
-                        return element(tag, attr, content)
-                    },
-                    this
-                )
-            );
-        });
-
-        Scope.method('each', function (object, callback) {
-            if (isString(object)) {
-                object = this.get(object, []);
-            }
-            each(object, callback);
+                    return function () {
+                        console.log('%s function not defined', COMPONENT);
+                    }
+                },
+                writable: false,
+                configurable: false,
+                enumerable: false,
+            },
+            getBlocks: {
+                value() {
+                    return this[BLOCKS]
+                },
+                writable: false,
+                configurable: false,
+                enumerable: false,
+            },
+            setExtend: {
+                value(value) {
+                    this[EXTEND] = value;
+                },
+                writable: false,
+                configurable: false,
+                enumerable: false,
+            },
+            getExtend: {
+                value() {
+                    return this[EXTEND]
+                },
+                writable: false,
+                configurable: false,
+                enumerable: false,
+            },
+            setLayout: {
+                value(layout) {
+                    this[LAYOUT] = layout;
+                },
+                writable: false,
+                configurable: false,
+                enumerable: false,
+            },
+            getLayout: {
+                value() {
+                    return this[LAYOUT]
+                },
+                writable: false,
+                configurable: false,
+                enumerable: false,
+            },
+            clone: {
+                value(exclude_blocks) {
+                    const filter = [LAYOUT, EXTEND, BUFFER];
+                    if (exclude_blocks === true) {
+                        filter.push(BLOCKS);
+                    }
+                    return omit(this, filter)
+                },
+                writable: false,
+                configurable: false,
+                enumerable: false,
+            },
+            extend: {
+                value(layout) {
+                    this.setExtend(true);
+                    this.setLayout(layout);
+                },
+                writable: false,
+                configurable: false,
+                enumerable: false,
+            },
+            echo: {
+                value(layout) {
+                    const buffer = this.getBuffer();
+                    const params = [].slice.call(arguments);
+                    params.forEach(buffer);
+                },
+                writable: false,
+                configurable: false,
+                enumerable: false,
+            },
+            fn: {
+                value(callback) {
+                    const buffer = this.getBuffer();
+                    const context = this;
+                    return function () {
+                        buffer.backup();
+                        if (isFunction(callback)) {
+                            callback.apply(context, arguments);
+                        }
+                        return buffer.restore()
+                    }
+                },
+                writable: false,
+                configurable: false,
+                enumerable: false,
+            },
+            get: {
+                value(name, defaults) {
+                    const path = getPath(this, name, true);
+                    const result = path.shift();
+                    const prop = path.pop();
+                    return hasProp(result, prop) ? result[prop] : defaults
+                },
+                writable: false,
+                configurable: false,
+                enumerable: false,
+            },
+            set: {
+                value(name, value) {
+                    const path = getPath(this, name, false);
+                    const result = path.shift();
+                    const prop = path.pop();
+                    if (this.getExtend() && hasProp(result, prop)) {
+                        return result[prop]
+                    }
+                    return (result[prop] = value)
+                },
+                writable: false,
+                configurable: false,
+                enumerable: false,
+            },
+            macro: {
+                value(name, callback) {
+                    const list = this.getMacro();
+                    const macro = this.fn(callback);
+                    const context = this;
+                    list[name] = function () {
+                        return context.echo(macro.apply(undefined, arguments))
+                    };
+                },
+                writable: false,
+                configurable: false,
+                enumerable: false,
+            },
+            call: {
+                value(name) {
+                    const list = this.getMacro();
+                    const macro = list[name];
+                    const params = [].slice.call(arguments, 1);
+                    if (isFunction(macro)) {
+                        return macro.apply(macro, params)
+                    }
+                },
+                writable: false,
+                configurable: false,
+                enumerable: false,
+            },
+            block: {
+                value(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()));
+                            }
+                        } else {
+                            return noop
+                        }
+                    };
+                    this.echo(current()(next()));
+                },
+                writable: false,
+                configurable: false,
+                enumerable: false,
+            },
+            include: {
+                value(path, data, cx) {
+                    const context = cx === false ? {} : this.clone(true);
+                    const params = extend(context, data || {});
+                    const promise = this.render(path, params);
+                    this.echo(promise);
+                },
+                writable: false,
+                configurable: false,
+                enumerable: false,
+            },
+            use: {
+                value(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
+                        )
+                    );
+                },
+                writable: false,
+                configurable: false,
+                enumerable: false,
+            },
+            async: {
+                value(promise, callback) {
+                    this.echo(
+                        resolve$1(
+                            promise,
+                            function (data) {
+                                return this.fn(callback)(data)
+                            },
+                            this
+                        )
+                    );
+                },
+                writable: false,
+                configurable: false,
+                enumerable: false,
+            },
+            each: {
+                value: function (object, callback) {
+                    if (isString(object)) {
+                        object = this.get(object, []);
+                    }
+                    each(object, callback);
+                },
+                writable: false,
+                configurable: false,
+                enumerable: false,
+            },
+            element: {
+                value(tag, attr, content) {
+                    return element(tag, attr, content)
+                },
+            },
+            el: {
+                value(tag, attr, content) {
+                    if (isFunction(content)) {
+                        content = this.fn(content)();
+                    }
+                    this.echo(
+                        resolve$1(
+                            content,
+                            function (content) {
+                                return this.element(tag, attr, content)
+                            },
+                            this
+                        )
+                    );
+                },
+                writable: false,
+                configurable: false,
+                enumerable: false,
+            },
         });
     };
-
     this.configure(config);
 }
 
@@ -794,7 +897,6 @@ function EJS(options) {
             return scope.getMacro()
         })
     };
-
     const render = function (name, data) {
         const filepath = ext(name, config.extension);
         const scope = context.create(data);
@@ -808,7 +910,6 @@ function EJS(options) {
             return content
         })
     };
-
     this.configure = function (options) {
         options = options || {};
         configSchema(config, options);
@@ -818,32 +919,26 @@ function EJS(options) {
         template.configure(config);
         return config
     };
-
     this.render = function (name, data) {
         return render(name, data)
     };
-
     this.helpers = function (methods) {
-        context.helpers(Object.assign(scope, methods || {}));
+        context.helpers(extend(scope, methods));
     };
-
     this.preload = function (list) {
         return cache.load(list || {})
     };
-
     this.create = function (options) {
         return new EJS(options)
     };
-
     this.compile = function (content, path) {
         return compiler.compile(content, path)
     };
-
     this.context = function (data) {
         return context.create(data)
     };
-
     this.helpers({ require, render });
+    return this
 }
 
 const ejs = new EJS();