@kosatyi/ejs 0.0.68 → 0.0.70

package/dist/esm/index.js

@@ -1,5 +1,5 @@
-import path from 'path';
 import fs from 'fs';
+import path from 'path';
 
 const typeProp = function () {
     const args = [].slice.call(arguments);
@@ -161,12 +161,23 @@ const hasProp = (object, prop) => {
     return object && object.hasOwnProperty(prop)
 };
 
+const joinPath = (path, template) => {
+    template = [path, template].join('/');
+    template = template.replace(/\/\//g, '/');
+    return template
+};
+
 const defaults = {};
+
 defaults.export = 'ejsPrecompiled';
 defaults.cache = true;
 defaults.chokidar = null;
 defaults.path = 'views';
-defaults.resolver = null;
+defaults.resolver = function (path, template) {
+    return Promise.resolve(
+        ['resolver is not defined', path, template].join(' ')
+    )
+};
 defaults.extension = 'ejs';
 defaults.rmWhitespace = true;
 defaults.withObject = true;
@@ -186,51 +197,6 @@ defaults.token = {
     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),
@@ -435,75 +401,99 @@ function Compiler(config) {
     this.configure(config);
 }
 
-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)
+
     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) {
+
+    const result = (template, content) => {
         cache.set(template, content);
         return content
     };
-    const resolve = function (path) {
+
+    const resolve = (path) => {
         return template.resolver(template.path, path)
     };
-    const compile = function (content, template) {
+
+    const compile = (content, template) => {
         if (isFunction(content)) {
             return content
         } else {
             return compiler.compile(content, template)
         }
     };
+
     this.configure = function (config) {
         template.path = config.path;
         template.cache = config.cache;
-        template.resolver = fileResolver(config.resolver);
+        if (isFunction(config.resolver)) {
+            template.resolver = config.resolver;
+        }
     };
+
     this.get = function (template) {
         if (cache.exist(template)) {
             return cache.resolve(template)
         }
-        return result(
-            template,
-            resolve(template).then((content) =>
-                result(template, compile(content, template))
-            )
+        return resolve(template).then((content) =>
+            result(template, compile(content, template))
         )
     };
     this.configure(config);
 }
 
+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('')
+};
+
 function resolve(list) {
     return Promise.all(list || []).then((list) => list.join(''))
 }
@@ -871,14 +861,18 @@ function Context(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) {
+
+    const output = (path, scope) => {
         return template.get(path).then(function (callback) {
             return callback.call(
                 scope,
@@ -889,14 +883,14 @@ function EJS(options) {
             )
         })
     };
-    const require = function (name) {
+    const require = (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 render = (name, data) => {
         const filepath = ext(name, config.extension);
         const scope = context.create(data);
         return output(filepath, scope).then((content) => {
@@ -940,36 +934,57 @@ function EJS(options) {
     return this
 }
 
-const ejs = new EJS();
-
-const { render, context, compile, helpers, preload, configure, create } =
-    ejs;
+function readFile(path, template) {
+    return new Promise((resolve, reject) => {
+        fs.readFile(joinPath(path, template), (error, data) => {
+            if (error) {
+                reject(error);
+            } else {
+                resolve(data.toString());
+            }
+        });
+    })
+}
 
-function __express(name, options, callback) {
-    if (isFunction(options)) {
-        callback = options;
-        options = {};
+/**
+ *
+ * @param {EJS} ejs
+ * @return {function(name, options, callback): Promise<String>}
+ */
+function expressRenderer(ejs) {
+    return function (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;
+        ejs.configure(viewOptions);
+        return ejs
+            .render(filename, options)
+            .then((content) => {
+                callback(null, content);
+            })
+            .catch((error) => {
+                callback(error);
+            })
     }
-    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 render(filename, options)
-        .then((content) => {
-            callback(null, content);
-        })
-        .catch((error) => {
-            callback(error);
-        })
 }
 
-export { EJS, __express, compile, configure, context, create, element, helpers, preload, render, safeValue };
+const ejs = new EJS({ resolver: readFile });
+
+const { render, context, compile, helpers, preload, configure, create } = ejs;
+
+const __express = expressRenderer(ejs);
+
+export { __express, compile, configure, context, create, helpers, preload, render };