@kosatyi/ejs 0.0.64 → 0.0.66

package/dist/esm/index.js

@@ -63,7 +63,7 @@ const safeValue = (value, escape) => {
 };
 
 const instanceOf = (object, instance) => {
-    return object instanceof instance
+    return Boolean(object instanceof instance)
 };
 
 const getPath = (context, name, strict) => {
@@ -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)
@@ -262,79 +264,55 @@ const configSchema = (config, options) => {
             config.rmWhitespace,
             options.rmWhitespace
         ),
-        cache: typeProp(isBoolean, defaults.watch, config.watch, options.watch),
+        cache: typeProp(isBoolean, defaults.cache, config.cache, options.cache),
         token: extend({}, defaults.token, config.token, options.token),
         vars: extend({}, defaults.vars, config.vars, options.vars),
     });
 };
 
-const resolvePath = (path, template) => {
-    template = [path, template].join('/');
-    template = template.replace(/\/\//g, '/');
-    return template
-};
-
-const httpRequest = (path, template) => {
-    return fetch(resolvePath(path, template)).then((response) =>
-        response.text()
-    )
-};
-
-const fileSystem = (path, template) => {
-    return new Promise((resolve, reject) => {
-        fs.readFile(resolvePath(path, template), (error, data) => {
-            if (error) {
-                reject(error);
-            } else {
-                resolve(data.toString());
-            }
-        });
-    })
-};
-
-const fileResolver = (resolver) => {
-    return isFunction(resolver) ? resolver : isNode() ? fileSystem : httpRequest
-};
-
-function Template(config, cache, compiler) {
-    if (instanceOf(this, Template) === false)
-        return new Template(config, cache, compiler)
-
-    const template = {};
+const global = typeof globalThis !== 'undefined' ? globalThis : window || self;
 
-    const result = function (template, content) {
-        cache.set(template, content);
-        return content
+function Cache(config) {
+    if (instanceOf(this, Cache) === false) return new Cache()
+    const cache = {
+        enabled: true,
+        list: {},
     };
-
-    const resolve = function (path) {
-        return template.resolver(template.path, path)
+    this.configure = function (config) {
+        cache.enabled = config.cache;
+        if (isNode() === false) {
+            this.load(global[config.export]);
+        }
     };
-
-    const compile = function (content, template) {
-        if (isFunction(content)) {
-            return content
-        } else {
-            return compiler.compile(content, template)
+    this.clear = function () {
+        cache.list = {};
+    };
+    this.load = function (data) {
+        if (cache.enabled) {
+            extend(cache.list, data || {});
         }
+        return this
     };
-    this.configure = function (config) {
-        template.path = config.path;
-        template.cache = config.cache;
-        template.resolver = fileResolver(config.resolver);
+    this.get = function (key) {
+        if (cache.enabled) {
+            return cache.list[key]
+        }
     };
-    this.get = function (template) {
-        if (cache.exist(template)) {
-            return cache.resolve(template)
+    this.set = function (key, value) {
+        if (cache.enabled) {
+            cache.list[key] = value;
         }
-        return result(
-            template,
-            resolve(template).then((content) =>
-                result(template, compile(content, template))
-            )
-        )
+        return this
+    };
+    this.resolve = function (key) {
+        return Promise.resolve(this.get(key))
+    };
+    this.remove = function (key) {
+        delete cache.list[key];
+    };
+    this.exist = function (key) {
+        return hasProp(cache.list, key)
     };
-    this.configure(config);
 }
 
 const tagList = [
@@ -457,54 +435,80 @@ function Compiler(config) {
     this.configure(config);
 }
 
-const global = typeof globalThis !== 'undefined' ? globalThis : window || self;
+const resolvePath = (path, template) => {
+    template = [path, template].join('/');
+    template = template.replace(/\/\//g, '/');
+    return template
+};
 
-function Cache(config) {
-    if (instanceOf(this, Cache) === false) return new Cache()
-    const cache = {
-        enabled: true,
-        list: {},
+const httpRequest = (path, template) => {
+    return fetch(resolvePath(path, template)).then((response) =>
+        response.text()
+    )
+};
+
+const fileSystem = (path, template) => {
+    return new Promise((resolve, reject) => {
+        fs.readFile(resolvePath(path, template), (error, data) => {
+            if (error) {
+                reject(error);
+            } else {
+                resolve(data.toString());
+            }
+        });
+    })
+};
+
+const fileResolver = (resolver) => {
+    return isFunction(resolver) ? resolver : isNode() ? fileSystem : httpRequest
+};
+
+function Template(config, cache, compiler) {
+    if (instanceOf(this, Template) === false)
+        return new Template(config, cache, compiler)
+    if (instanceOf(cache, Cache) === false)
+        throw new TypeError('cache is not instance of Cache')
+    if (instanceOf(compiler, Compiler) === false)
+        throw new TypeError('compiler is not instance of Compiler')
+    const template = {};
+    const result = function (template, content) {
+        cache.set(template, content);
+        return content
     };
-    this.configure = function (config) {
-        cache.list = {};
-        cache.enabled = config.cache;
-        if (isNode() === false) {
-            this.load(global[config.export]);
-        }
+    const resolve = function (path) {
+        return template.resolver(template.path, path)
     };
-    this.load = function (data) {
-        if (cache.enabled) {
-            extend(cache.list, data || {});
+    const compile = function (content, template) {
+        if (isFunction(content)) {
+            return content
+        } else {
+            return compiler.compile(content, template)
         }
-        return this
     };
-    this.get = function (key) {
-        if (cache.enabled) {
-            return cache.list[key]
-        }
+    this.configure = function (config) {
+        template.path = config.path;
+        template.cache = config.cache;
+        template.resolver = fileResolver(config.resolver);
     };
-    this.set = function (key, value) {
-        if (cache.enabled) {
-            cache.list[key] = value;
+    this.get = function (template) {
+        if (cache.exist(template)) {
+            return cache.resolve(template)
         }
-        return this
-    };
-    this.resolve = function (key) {
-        return Promise.resolve(this.get(key))
-    };
-    this.remove = function (key) {
-        delete cache.list[key];
-    };
-    this.exist = function (key) {
-        return hasProp(cache.list, key)
+        return result(
+            template,
+            resolve(template).then((content) =>
+                result(template, compile(content, template))
+            )
+        )
     };
+    this.configure(config);
 }
 
 function resolve(list) {
     return Promise.all(list || []).then((list) => list.join(''))
 }
 
-const createBuffer = function () {
+function createBuffer() {
     let store = [],
         array = [];
     function buffer(value) {
@@ -529,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;
 
@@ -543,6 +546,7 @@ function Context(config) {
 
         this.helpers = function (methods) {
             extend(Scope.prototype, methods || {});
+            console.log('helpers', Scope.prototype);
         };
 
         function Scope(data) {
@@ -550,234 +554,331 @@ 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);
 }
 
 function EJS(options) {
     if (instanceOf(this, EJS) === false) return new EJS(options)
-
     const scope = {};
     const config = {};
-
     configSchema(config, options || {});
-
     const context = new Context(config);
     const compiler = new Compiler(config);
     const cache = new Cache();
     const template = new Template(config, cache, compiler);
-
     const output = function (path, scope) {
         return template.get(path).then(function (callback) {
             return callback.call(
@@ -789,7 +890,6 @@ function EJS(options) {
             )
         })
     };
-
     const require = function (name) {
         const filepath = ext(name, config.extension);
         const scope = context.create({});
@@ -797,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);
@@ -811,7 +910,6 @@ function EJS(options) {
             return content
         })
     };
-
     this.configure = function (options) {
         options = options || {};
         configSchema(config, options);
@@ -821,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();
@@ -872,7 +964,7 @@ function __express(name, options, callback) {
     viewOptions.path = viewPath;
     viewOptions.cache = viewCache;
     configure(viewOptions);
-    return this.render(filename, options)
+    return render(filename, options)
         .then((content) => {
             callback(null, content);
         })