@kosatyi/ejs 0.0.54 → 0.0.56

package/dist/esm/index.js

@@ -1,38 +1,5 @@
-import path from 'path';
 import fs from 'fs';
-
-const defaults = {};
-
-defaults.export = 'ejsPrecompiled';
-
-defaults.watch = false;
-
-defaults.path = 'views';
-
-defaults.resolver = null;
-
-defaults.extension = 'ejs';
-
-defaults.rmWhitespace = true;
-
-defaults.withObject = true;
-
-defaults.vars = {
-    SCOPE: 'ejs',
-    COMPONENT: 'ui',
-    EXTEND: '$$e',
-    BUFFER: '$$a',
-    LAYOUT: '$$l',
-    BLOCKS: '$$b',
-    MACRO: '$$m',
-    SAFE: '$$v',
-};
-
-defaults.token = {
-    start: '<%',
-    end: '%>',
-    regex: '([\\s\\S]+?)',
-};
+import path from 'path';
 
 const typeProp = function () {
     const args = [].slice.call(arguments);
@@ -105,6 +72,14 @@ const getPath = (context, name) => {
     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) {
@@ -179,50 +154,165 @@ const hasProp = (object, prop) => {
     return object && object.hasOwnProperty(prop)
 };
 
-const selfClosed = [
-    'area',
-    'base',
-    'br',
-    'col',
-    'embed',
-    'hr',
-    'img',
-    'input',
-    'link',
-    'meta',
-    'param',
-    'source',
-    'track',
-    'wbr',
-];
+const defaults = {};
 
-const space = ' ';
-const quote = '"';
-const equal = '=';
-const slash = '/';
-const lt = '<';
-const gt = '>';
+defaults.export = 'ejsPrecompiled';
 
-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)
+defaults.watch = false;
+
+defaults.chokidar = null;
+
+defaults.path = 'views';
+
+defaults.resolver = null;
+
+defaults.extension = 'ejs';
+
+defaults.rmWhitespace = true;
+
+defaults.withObject = true;
+
+defaults.vars = {
+    SCOPE: 'ejs',
+    COMPONENT: 'ui',
+    EXTEND: '$$e',
+    BUFFER: '$$a',
+    LAYOUT: '$$l',
+    BLOCKS: '$$b',
+    MACRO: '$$m',
+    SAFE: '$$v',
+};
+
+defaults.token = {
+    start: '<%',
+    end: '%>',
+    regex: '([\\s\\S]+?)',
+};
+
+const configSchema = (config, options) => {
+    extend(config, {
+        path: typeProp(isString, defaults.path, config.path, options.path),
+        export: typeProp(
+            isString,
+            defaults.export,
+            config.export,
+            options.export
+        ),
+        resolver: typeProp(
+            isFunction,
+            defaults.resolver,
+            config.resolver,
+            options.resolver
+        ),
+        extension: typeProp(
+            isString,
+            defaults.extension,
+            config.extension,
+            options.extension
+        ),
+        withObject: typeProp(
+            isBoolean,
+            defaults.withObject,
+            config.withObject,
+            options.withObject
+        ),
+        rmWhitespace: typeProp(
+            isBoolean,
+            defaults.rmWhitespace,
+            config.rmWhitespace,
+            options.rmWhitespace
+        ),
+        watch: typeProp(isBoolean, defaults.watch, config.watch, options.watch),
+        chokidar: typeProp(
+            isObject,
+            defaults.export,
+            config.export,
+            options.export
+        ),
+        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());
+            }
+        });
+    })
+};
+
+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);
+                    });
+            }
         }
-    }).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(''));
+    resolve(template) {
+        return this.resolver(this.path, template)
     }
-    return result.join('')
-};
+    result(template, content) {
+        this.cache.set(template, content);
+        return content
+    }
+    compile(content, template) {
+        if (isFunction(content)) {
+            return content
+        } else {
+            return this.compiler.compile(content, template)
+        }
+    }
+    get(template) {
+        if (this.cache.exist(template)) {
+            return this.cache.resolve(template)
+        }
+        const content = this.resolve(template).then((content) =>
+            this.result(template, this.compile(content, template))
+        );
+        return this.result(template, content)
+    }
+}
 
 const tagList = [
     {
@@ -343,84 +433,87 @@ class Compiler {
     }
 }
 
-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 global = typeof globalThis !== 'undefined' ? globalThis : window || self;
 
-class Template {
-    constructor(config, cache, compiler) {
-        this.cache = cache;
-        this.watcher = null;
-        this.compiler = compiler;
+class Cache {
+    list = {}
+    constructor(config) {
         this.configure(config);
+        if (isNode() === false) {
+            this.load(global[this.namespace]);
+        }
     }
     configure(config) {
-        this.path = config.path;
-        this.chokidar = config.chokidar;
-        this.resolver = isFunction(config.resolver)
-            ? config.resolver
-            : isNode()
-            ? fileSystem
-            : httpRequest;
-        if (config.watch && config.chokidar && isNode()) {
-            if (this.watcher) {
-                this.watcher.unwatch('.');
-            }
-            this.watcher = this.chokidar
-                .watch('.', { cwd: this.path })
-                .on('change', (name) => {
-                    this.cache.remove(name);
-                })
-                .on('error', (error) => {
-                    console.log('watcher error: ' + error);
-                });
-        }
+        this.list = {};
+        this.namespace = config.export;
     }
-    resolve(template) {
-        return this.resolver(this.path, template)
+    load(data) {
+        extend(this.list, data);
+        return this
     }
-    result(template, content) {
-        this.cache.set(template, content);
-        return content
+    exist(key) {
+        return hasProp(this.list, key)
     }
-    compile(content, template) {
-        if (isFunction(content)) {
-            return content
-        } else {
-            return this.compiler.compile(content, template)
-        }
+    get(key) {
+        return this.list[key]
     }
-    get(template) {
-        if (this.cache.exist(template)) {
-            return this.cache.resolve(template)
-        }
-        const content = this.resolve(template).then((content) =>
-            this.result(template, this.compile(content, template))
-        );
-        return this.result(template, content)
+    remove(key) {
+        delete this.list[key];
+    }
+    resolve(key) {
+        return Promise.resolve(this.get(key))
+    }
+    set(key, value) {
+        this.list[key] = value;
+        return this
     }
 }
 
+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(''));
 
 const createBuffer = () => {
@@ -699,109 +792,38 @@ class Context {
     }
 }
 
-const global = typeof globalThis !== 'undefined' ? globalThis : window || self;
-
-class Cache {
-    list = {}
-    constructor(config) {
-        this.configure(config);
-        if (isNode() === false) {
-            this.load(global[this.namespace]);
-        }
-    }
-    configure(config) {
-        this.list = {};
-        this.namespace = config.export;
-    }
-    load(data) {
-        extend(this.list, data);
-        return this
-    }
-    exist(key) {
-        return hasProp(this.list, key)
-    }
-    get(key) {
-        return this.list[key]
+class EJS {
+    export = [
+        'cache',
+        'render',
+        'require',
+        'helpers',
+        'configure',
+        'preload',
+        'compiler',
+        '__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 });
     }
-    remove(key) {
-        delete this.list[key];
+    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
     }
-    resolve(key) {
-        return Promise.resolve(this.get(key))
-    }
-    set(key, value) {
-        this.list[key] = value;
-        return this
-    }
-}
-
-const configSchema = (config, options) => {
-    extend(config, {
-        path: typeProp(isString, defaults.path, config.path, options.path),
-        export: typeProp(
-            isString,
-            defaults.export,
-            config.export,
-            options.export
-        ),
-        resolver: typeProp(
-            isFunction,
-            defaults.resolver,
-            config.resolver,
-            options.resolver
-        ),
-        extension: typeProp(
-            isString,
-            defaults.extension,
-            config.extension,
-            options.extension
-        ),
-        withObject: typeProp(
-            isBoolean,
-            defaults.withObject,
-            config.withObject,
-            options.withObject
-        ),
-        rmWhitespace: typeProp(
-            isBoolean,
-            defaults.rmWhitespace,
-            config.rmWhitespace,
-            options.rmWhitespace
-        ),
-        watch: typeProp(isBoolean, defaults.watch, config.watch, options.watch),
-        chokidar: typeProp(
-            isObject,
-            defaults.export,
-            config.export,
-            options.export
-        ),
-        token: extend({}, defaults.token, config.token, options.token),
-        vars: extend({}, defaults.vars, config.vars, options.vars),
-    });
-};
-
-const create = (options) => {
-    const config = {};
-    const scope = {};
-
-    configSchema(config, options || {});
-
-    const context = new Context(config);
-    const compiler = new Compiler(config);
-    const cache = new Cache(config);
-    const template = new Template(config, cache, compiler);
-
-    const configure = (options) => {
-        configSchema(config, options);
-        context.configure(config, scope);
-        compiler.configure(config);
-        cache.configure(config);
-        template.configure(config);
-        return config
-    };
-
-    const output = (path, scope) => {
-        return template.get(path).then(function (callback) {
+    output(path, scope) {
+        return this.template.get(path).then(function (callback) {
             return callback.call(
                 scope,
                 scope,
@@ -810,35 +832,40 @@ const create = (options) => {
                 safeValue
             )
         })
-    };
-
-    const require = (name) => {
-        const filepath = ext(name, config.extension);
-        const scope = context.create({});
-        return output(filepath, scope).then(() => {
-            return scope.getMacro()
-        })
-    };
-
-    const render = (name, data) => {
-        const filepath = ext(name, config.extension);
-        const scope = context.create(data);
-        return output(filepath, scope).then((content) => {
+    }
+    render(name, data) {
+        const filepath = ext(name, this.config.extension);
+        const scope = this.context.create(data);
+        return this.output(filepath, scope).then((content) => {
             if (scope.getExtend()) {
                 scope.setExtend(false);
                 const layout = scope.getLayout();
                 const data = scope.clone();
-                return render(layout, data)
+                return this.render(layout, data)
             }
             return content
         })
-    };
-
-    const helpers = (methods) => {
-        context.helpers(extend(scope, methods || {}));
-    };
-
-    const __express = (name, options, callback) => {
+    }
+    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 = {};
@@ -855,42 +882,30 @@ const create = (options) => {
         const filename = path.relative(viewPath, name);
         viewOptions.path = viewPath;
         viewOptions.cache = viewCache;
-        configure(viewOptions);
-        return render(filename, options)
+        this.configure(viewOptions);
+        return this.render(filename, options)
             .then((content) => {
                 callback(null, content);
             })
             .catch((error) => {
                 callback(error);
             })
-    };
-
-    const preload = (list) => cache.load(list);
-
-    const compile = (content, path) => compiler.compile(content, path);
-
-    helpers({ require, render });
-
-    return {
-        context,
-        render,
-        helpers,
-        configure,
-        compile,
-        create,
-        preload,
-        __express,
     }
-};
+}
+
+const ejs = new EJS({
+    /** defaults options **/
+});
 
 const {
-    context,
+    __express,
     render,
-    helpers,
-    configure,
+    context,
     compile,
+    helpers,
     preload,
-    __express,
-} = create({});
+    configure,
+    create,
+} = ejs;
 
-export { __express, compile, configure, context, create, element, helpers, preload, render, safeValue };
+export { EJS, __express, compile, configure, context, create, element, helpers, preload, render, safeValue };