@kosatyi/ejs 0.0.62 → 0.0.64

package/dist/esm/index.js

@@ -1,5 +1,5 @@
-import fs from 'fs';
 import path from 'path';
+import fs from 'fs';
 
 const typeProp = function () {
     const args = [].slice.call(arguments);
@@ -9,7 +9,6 @@ const typeProp = function () {
 const isFunction = (v) => typeof v === 'function';
 const isString = (v) => typeof v === 'string';
 const isBoolean = (v) => typeof v === 'boolean';
-const isObject = (v) => typeof v === 'object';
 const isUndefined = (v) => typeof v === 'undefined';
 
 const isNodeEnv =
@@ -58,32 +57,36 @@ const symbols = (string) => {
     )
 };
 
-const safeValue = (value, escape, check) => {
-    return (check = value) == null ? '' : escape ? entities(check) : check
+const safeValue = (value, escape) => {
+    const check = value;
+    return check == null ? '' : escape === true ? entities(check) : check
+};
+
+const instanceOf = (object, instance) => {
+    return object instanceof instance
 };
 
 const getPath = (context, name, strict) => {
     let data = context;
     let chunks = String(name).split('.');
     let prop = chunks.pop();
-    for (const part of chunks) {
+    for (let i = 0; i < chunks.length; i++) {
+        const part = chunks[i];
+        if (isFunction(data['toJSON'])) {
+            data = data.toJSON();
+        }
         if (strict && data.hasOwnProperty(part) === false) {
             data = {};
             break
         }
         data = data[part] = data[part] || {};
     }
+    if (isFunction(data['toJSON'])) {
+        data = data.toJSON();
+    }
     return [data, prop]
 };
 
-const bindContext = (object, context, methods = []) => {
-    methods.forEach((name) => {
-        if (name in object) {
-            object[name] = object[name].bind(context);
-        }
-    });
-};
-
 const ext = (path, defaults) => {
     const ext = path.split('.').pop();
     if (ext !== defaults) {
@@ -96,9 +99,7 @@ const extend = (...args) => {
     const target = args.shift();
     return args
         .filter((source) => source)
-        .reduce((target, source) => {
-            return Object.assign(target, source)
-        }, target)
+        .reduce((target, source) => Object.assign(target, source), target)
 };
 
 const noop = () => {};
@@ -159,23 +160,14 @@ const hasProp = (object, prop) => {
 };
 
 const defaults = {};
-
 defaults.export = 'ejsPrecompiled';
-
-defaults.watch = false;
-
+defaults.cache = true;
 defaults.chokidar = null;
-
 defaults.path = 'views';
-
 defaults.resolver = null;
-
 defaults.extension = 'ejs';
-
 defaults.rmWhitespace = true;
-
 defaults.withObject = true;
-
 defaults.vars = {
     SCOPE: 'ejs',
     COMPONENT: 'ui',
@@ -186,13 +178,57 @@ defaults.vars = {
     MACRO: '$$m',
     SAFE: '$$v',
 };
-
 defaults.token = {
     start: '<%',
     end: '%>',
     regex: '([\\s\\S]+?)',
 };
 
+const selfClosed = [
+    'area',
+    'base',
+    'br',
+    'col',
+    'embed',
+    'hr',
+    'img',
+    'input',
+    'link',
+    'meta',
+    'param',
+    'source',
+    'track',
+    'wbr',
+];
+
+const space = ' ';
+const quote = '"';
+const equal = '=';
+const slash = '/';
+const lt = '<';
+const gt = '>';
+
+const element = (tag, attrs, content) => {
+    const result = [];
+    const hasClosedTag = selfClosed.indexOf(tag) === -1;
+    const attributes = map(attrs, (value, key) => {
+        if (value !== null && value !== undefined) {
+            return [
+                entities(key),
+                [quote, entities(value), quote].join(''),
+            ].join(equal)
+        }
+    }).join(space);
+    result.push([lt, tag, space, attributes, gt].join(''));
+    if (content) {
+        result.push(content instanceof Array ? content.join('') : content);
+    }
+    if (hasClosedTag) {
+        result.push([lt, slash, tag, gt].join(''));
+    }
+    return result.join('')
+};
+
 const configSchema = (config, options) => {
     extend(config, {
         path: typeProp(isString, defaults.path, config.path, options.path),
@@ -226,13 +262,7 @@ const configSchema = (config, options) => {
             config.rmWhitespace,
             options.rmWhitespace
         ),
-        watch: typeProp(isBoolean, defaults.watch, config.watch, options.watch),
-        chokidar: typeProp(
-            isObject,
-            defaults.export,
-            config.export,
-            options.export
-        ),
+        cache: typeProp(isBoolean, defaults.watch, config.watch, options.watch),
         token: extend({}, defaults.token, config.token, options.token),
         vars: extend({}, defaults.vars, config.vars, options.vars),
     });
@@ -262,60 +292,49 @@ const fileSystem = (path, template) => {
     })
 };
 
-class Template {
-    constructor(config, cache, compiler) {
-        this.cache = cache;
-        this.watcher = {
-            unwatch() {},
-            on() {},
-        };
-        this.compiler = compiler;
-        this.configure(config);
-    }
-    configure(config) {
-        this.path = config.path;
-        this.chokidar = config.chokidar;
-        this.resolver = isFunction(config.resolver)
-            ? config.resolver
-            : isNode()
-            ? fileSystem
-            : httpRequest;
-        if (config.watch && isNode()) {
-            if (this.watcher) {
-                this.watcher.unwatch('.');
-            }
-            if (this.chokidar) {
-                this.watcher = this.chokidar
-                    .watch('.', { cwd: this.path })
-                    .on('change', (name) => {
-                        this.cache.remove(name);
-                    });
-            }
-        }
-    }
-    resolve(template) {
-        return this.resolver(this.path, template)
-    }
-    result(template, content) {
-        this.cache.set(template, content);
+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 result = function (template, content) {
+        cache.set(template, content);
         return content
-    }
-    compile(content, template) {
+    };
+
+    const resolve = function (path) {
+        return template.resolver(template.path, path)
+    };
+
+    const compile = function (content, template) {
         if (isFunction(content)) {
             return content
         } else {
-            return this.compiler.compile(content, template)
+            return compiler.compile(content, template)
         }
-    }
-    get(template) {
-        if (this.cache.exist(template)) {
-            return this.cache.resolve(template)
+    };
+    this.configure = function (config) {
+        template.path = config.path;
+        template.cache = config.cache;
+        template.resolver = fileResolver(config.resolver);
+    };
+    this.get = function (template) {
+        if (cache.exist(template)) {
+            return cache.resolve(template)
         }
-        const content = this.resolve(template).then((content) =>
-            this.result(template, this.compile(content, template))
-        );
-        return this.result(template, content)
-    }
+        return result(
+            template,
+            resolve(template).then((content) =>
+                result(template, compile(content, template))
+            )
+        )
+    };
+    this.configure(config);
 }
 
 const tagList = [
@@ -345,7 +364,7 @@ const tagList = [
     },
 ];
 
-const matchTokens = (regex, text, callback) => {
+function matchTokens(regex, text, callback) {
     let index = 0;
     text.replace(regex, function () {
         const params = [].slice.call(arguments, 0, -1);
@@ -355,71 +374,70 @@ const matchTokens = (regex, text, callback) => {
         index = offset + match.length;
         return match
     });
-};
+}
 
-class Compiler {
-    constructor(config) {
-        this.configure(config);
-    }
+function Compiler(config) {
+    if (instanceOf(this, Compiler) === false) return new Compiler(config)
+
+    const compiler = {};
 
-    configure(config) {
-        this.withObject = config.withObject;
-        this.rmWhitespace = config.rmWhitespace;
-        this.token = config.token;
-        this.vars = config.vars;
-        this.matches = [];
-        this.formats = [];
-        this.slurp = {
+    this.configure = function (config) {
+        compiler.withObject = config.withObject;
+        compiler.rmWhitespace = config.rmWhitespace;
+        compiler.token = config.token;
+        compiler.vars = config.vars;
+        compiler.matches = [];
+        compiler.formats = [];
+        compiler.slurp = {
             match: '[ \\t]*',
-            start: [this.token.start, '_'],
-            end: ['_', this.token.end],
+            start: [compiler.token.start, '_'],
+            end: ['_', compiler.token.end],
         };
         tagList.forEach((item) => {
-            this.matches.push(
-                this.token.start
+            compiler.matches.push(
+                compiler.token.start
                     .concat(item.symbol)
-                    .concat(this.token.regex)
-                    .concat(this.token.end)
+                    .concat(compiler.token.regex)
+                    .concat(compiler.token.end)
             );
-            this.formats.push(item.format.bind(this.vars));
+            compiler.formats.push(item.format.bind(compiler.vars));
         });
-        this.regex = new RegExp(this.matches.join('|').concat('|$'), 'g');
-        this.slurpStart = new RegExp(
-            [this.slurp.match, this.slurp.start.join('')].join(''),
+        compiler.regex = new RegExp(
+            compiler.matches.join('|').concat('|$'),
+            'g'
+        );
+        compiler.slurpStart = new RegExp(
+            [compiler.slurp.match, compiler.slurp.start.join('')].join(''),
             'gm'
         );
-        this.slurpEnd = new RegExp(
-            [this.slurp.end.join(''), this.slurp.match].join(''),
+        compiler.slurpEnd = new RegExp(
+            [compiler.slurp.end.join(''), compiler.slurp.match].join(''),
             'gm'
         );
-    }
-
-    truncate(value) {
-        return value && value.replace(/^(?:\r\n|\r|\n)/, '')
-    }
+    };
 
-    compile(content, path) {
-        const { SCOPE, SAFE, BUFFER, COMPONENT } = this.vars;
-        if (this.rmWhitespace) {
+    this.compile = function (content, path) {
+        const { SCOPE, SAFE, BUFFER, COMPONENT } = compiler.vars;
+        if (compiler.rmWhitespace) {
             content = content
                 .replace(/[\r\n]+/g, '\n')
                 .replace(/^\s+|\s+$/gm, '');
         }
         content = content
-            .replace(this.slurpStart, this.token.start)
-            .replace(this.slurpEnd, this.token.end);
+            .replace(compiler.slurpStart, compiler.token.start)
+            .replace(compiler.slurpEnd, compiler.token.end);
         let source = `${BUFFER}('`;
-        matchTokens(this.regex, content, (params, index, offset) => {
+        matchTokens(compiler.regex, content, (params, index, offset) => {
             source += symbols(content.slice(index, offset));
             params.forEach((value, index) => {
                 if (value) {
-                    source += this.formats[index](value);
+                    source += compiler.formats[index](value);
                 }
             });
         });
         source += `');`;
         source = `try{${source}}catch(e){console.info(e)}`;
-        if (this.withObject) {
+        if (compiler.withObject) {
             source = `with(${SCOPE}){${source}}`;
         }
         source = `${BUFFER}.start();${source}return ${BUFFER}.end();`;
@@ -434,92 +452,59 @@ class Compiler {
             throw e
         }
         return result
-    }
+    };
+
+    this.configure(config);
 }
 
 const global = typeof globalThis !== 'undefined' ? globalThis : window || self;
 
-class Cache {
-    list = {}
-    constructor(config) {
-        this.configure(config);
-    }
-    configure(config) {
-        this.list = {};
+function Cache(config) {
+    if (instanceOf(this, Cache) === false) return new Cache()
+    const cache = {
+        enabled: true,
+        list: {},
+    };
+    this.configure = function (config) {
+        cache.list = {};
+        cache.enabled = config.cache;
         if (isNode() === false) {
             this.load(global[config.export]);
         }
-    }
-    load(data) {
-        extend(this.list, data);
+    };
+    this.load = function (data) {
+        if (cache.enabled) {
+            extend(cache.list, data || {});
+        }
         return this
-    }
-    exist(key) {
-        return hasProp(this.list, key)
-    }
-    get(key) {
-        return this.list[key]
-    }
-    remove(key) {
-        delete this.list[key];
-    }
-    resolve(key) {
-        return Promise.resolve(this.get(key))
-    }
-    set(key, value) {
-        this.list[key] = value;
+    };
+    this.get = function (key) {
+        if (cache.enabled) {
+            return cache.list[key]
+        }
+    };
+    this.set = function (key, value) {
+        if (cache.enabled) {
+            cache.list[key] = value;
+        }
         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)
+    };
 }
 
-const selfClosed = [
-    'area',
-    'base',
-    'br',
-    'col',
-    'embed',
-    'hr',
-    'img',
-    'input',
-    'link',
-    'meta',
-    'param',
-    'source',
-    'track',
-    'wbr',
-];
-
-const space = ' ';
-const quote = '"';
-const equal = '=';
-const slash = '/';
-const lt = '<';
-const gt = '>';
-
-const element = (tag, attrs, content) => {
-    const result = [];
-    const hasClosedTag = selfClosed.indexOf(tag) === -1;
-    const attributes = map(attrs, (value, key) => {
-        if (value !== null && value !== undefined) {
-            return [
-                entities(key),
-                [quote, entities(value), quote].join(''),
-            ].join(equal)
-        }
-    }).join(space);
-    result.push([lt, tag, space, attributes, gt].join(''));
-    if (content) {
-        result.push(content instanceof Array ? content.join('') : content);
-    }
-    if (hasClosedTag) {
-        result.push([lt, slash, tag, gt].join(''));
-    }
-    return result.join('')
-};
-
-const resolve = (list) => Promise.all(list).then((list) => list.join(''));
+function resolve(list) {
+    return Promise.all(list || []).then((list) => list.join(''))
+}
 
-const createBuffer = () => {
+const createBuffer = function () {
     let store = [],
         array = [];
     function buffer(value) {
@@ -546,64 +531,47 @@ const createBuffer = () => {
     return buffer
 };
 
-class Context {
-    constructor(config) {
-        this.configure(config);
-    }
-    configure(config, methods) {
-        const { EXTEND, LAYOUT, BLOCKS, BUFFER, MACRO, COMPONENT } = config.vars;
-        this.create = (data) => {
+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;
+
+        this.create = function (data) {
             return new Scope(data)
         };
-        this.helpers = (methods) => {
-            extend(Scope.prototype, methods);
+
+        this.helpers = function (methods) {
+            extend(Scope.prototype, methods || {});
         };
-        function Scope(data = {}) {
-            this.initBlocks();
-            this.initMacro();
-            extend(this, data);
+
+        function Scope(data) {
+            this[BLOCKS] = {};
+            this[MACRO] = {};
+            extend(this, data || {});
         }
         Scope.prototype = extend({}, methods || {});
-        /**
-         * @param {string} name
-         * @param {*} value
-         * @param {boolean} [writable]
-         * @param {boolean} [configurable]
-         * @param {boolean} [enumerable]
-         */
-        Scope.define = Scope.method = (
+        Scope.method = Scope.define = function (
             name,
             value,
             writable,
             configurable,
             enumerable
-        ) => {
-            return Object.defineProperty(Scope.prototype, name, {
+        ) {
+            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('initBlocks', function () {
-            this[BLOCKS] = {};
-        });
-
-        Scope.method('initMacro', function () {
-            this[MACRO] = {};
-        });
-
         Scope.method('getMacro', function () {
             return this[MACRO]
         });
@@ -792,42 +760,26 @@ class Context {
             }
             each(object, callback);
         });
-    }
+    };
+
+    this.configure(config);
 }
 
-class EJS {
-    export = [
-        'cache',
-        'render',
-        'require',
-        'helpers',
-        'configure',
-        'preload',
-        'compile',
-        'create',
-        '__express',
-    ]
-    constructor(options = {}) {
-        this.config = {};
-        this.scope = {};
-        configSchema(this.config, options);
-        bindContext(this, this, this.export);
-        this.context = new Context(this.config);
-        this.compiler = new Compiler(this.config);
-        this.cache = new Cache(this.config);
-        this.template = new Template(this.config, this.cache, this.compiler);
-        this.helpers({ require: this.require, render: this.render });
-    }
-    configure(options = {}) {
-        configSchema(this.config, options);
-        this.context.configure(this.config, this.scope);
-        this.compiler.configure(this.config);
-        this.cache.configure(this.config);
-        this.template.configure(this.config);
-        return this.config
-    }
-    output(path, scope) {
-        return this.template.get(path).then(function (callback) {
+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(
                 scope,
                 scope,
@@ -836,80 +788,97 @@ class EJS {
                 safeValue
             )
         })
-    }
-    render(name, data) {
-        const filepath = ext(name, this.config.extension);
-        const scope = this.context.create(data);
-        return this.output(filepath, scope).then((content) => {
+    };
+
+    const require = function (name) {
+        const filepath = ext(name, config.extension);
+        const scope = context.create({});
+        return output(filepath, scope).then(() => {
+            return scope.getMacro()
+        })
+    };
+
+    const render = function (name, data) {
+        const filepath = ext(name, config.extension);
+        const scope = context.create(data);
+        return output(filepath, scope).then((content) => {
             if (scope.getExtend()) {
                 scope.setExtend(false);
                 const layout = scope.getLayout();
                 const data = scope.clone();
-                return this.render(layout, data)
+                return render(layout, data)
             }
             return content
         })
-    }
-    require(name) {
-        const filepath = ext(name, this.config.extension);
-        const scope = this.context.create({});
-        return this.output(filepath, scope).then(() => {
-            return scope.getMacro()
-        })
-    }
-    create(options = {}) {
-        return new EJS(options)
-    }
-    helpers(methods = {}) {
-        this.context.helpers(extend(this.scope, methods));
-    }
-    preload(list = {}) {
-        return this.cache.load(list)
-    }
-    compile(content, path) {
-        return this.compiler.compile(content, path)
-    }
-    __express(name, options, callback) {
-        if (isFunction(options)) {
-            callback = options;
-            options = {};
-        }
+    };
+
+    this.configure = function (options) {
         options = options || {};
-        const settings = extend({}, options.settings);
-        const viewPath = typeProp(isString, defaults.path, settings['views']);
-        const viewCache = typeProp(
-            isBoolean,
-            defaults.cache,
-            settings['view cache']
-        );
-        const viewOptions = extend({}, settings['view options']);
-        const filename = path.relative(viewPath, name);
-        viewOptions.path = viewPath;
-        viewOptions.cache = viewCache;
-        this.configure(viewOptions);
-        return this.render(filename, options)
-            .then((content) => {
-                callback(null, content);
-            })
-            .catch((error) => {
-                callback(error);
-            })
-    }
+        configSchema(config, options);
+        context.configure(config, scope);
+        compiler.configure(config);
+        cache.configure(config);
+        template.configure(config);
+        return config
+    };
+
+    this.render = function (name, data) {
+        return render(name, data)
+    };
+
+    this.helpers = function (methods) {
+        context.helpers(Object.assign(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 });
 }
 
-const ejs = new EJS({
-    /** defaults options **/
-});
-
-const {
-    __express,
-    render,
-    context,
-    compile,
-    helpers,
-    preload,
-    configure,
-    create,
-} = ejs;
+const ejs = new EJS();
+
+const { render, context, compile, helpers, preload, configure, create } =
+    ejs;
+
+function __express(name, options, callback) {
+    if (isFunction(options)) {
+        callback = options;
+        options = {};
+    }
+    options = options || {};
+    const settings = extend({}, options.settings);
+    const viewPath = typeProp(isString, defaults.path, settings['views']);
+    const viewCache = typeProp(
+        isBoolean,
+        defaults.cache,
+        settings['view cache']
+    );
+    const viewOptions = extend({}, settings['view options']);
+    const filename = path.relative(viewPath, name);
+    viewOptions.path = viewPath;
+    viewOptions.cache = viewCache;
+    configure(viewOptions);
+    return this.render(filename, options)
+        .then((content) => {
+            callback(null, content);
+        })
+        .catch((error) => {
+            callback(error);
+        })
+}
 
 export { EJS, __express, compile, configure, context, create, element, helpers, preload, render, safeValue };