@kosatyi/ejs 0.0.104 → 0.0.106

package/dist/esm/browser.js

@@ -64,15 +64,6 @@ const safeValue = (value, escape) => {
         : check
 };
 
-const instanceOf = (object, instance) => {
-    return Boolean(object instanceof instance)
-};
-
-const assertInstanceOf = (object, instance) => {
-    if (instanceOf(object, instance) === false)
-        throw new TypeError(`${object} in not instance of ${instance}`)
-};
-
 const getPath = (context, name, strict) => {
     let data = context;
     let chunks = String(name).split('.');
@@ -94,14 +85,6 @@ const getPath = (context, name, strict) => {
     return [data, prop]
 };
 
-const bindContext = (object, methods = []) => {
-    methods.forEach((name) => {
-        if (name in object) {
-            object[name] = object[name].bind(object);
-        }
-    });
-};
-
 const ext = (path, defaults) => {
     const ext = path.split('.').pop();
     if (ext !== defaults) {
@@ -203,7 +186,7 @@ defaults.export = 'ejsPrecompiled';
 defaults.cache = true;
 defaults.chokidar = null;
 defaults.path = 'views';
-defaults.resolver = function (path, template) {
+defaults.resolver = function(path, template) {
     return Promise.resolve(
         ['resolver is not defined', path, template].join(' ')
     )
@@ -221,16 +204,16 @@ defaults.vars = {
     LAYOUT: '$$l',
     BLOCKS: '$$b',
     MACRO: '$$m',
-    SAFE: '$$v',
+    SAFE: '$$v'
 };
 defaults.token = {
     start: '<%',
     end: '%>',
-    regex: '([\\s\\S]+?)',
+    regex: '([\\s\\S]+?)'
 };
 
 const configSchema = (config, options) => {
-    extend(config, {
+    return extend(config, {
         path: typeProp(isString, defaults.path, config.path, options.path),
         export: typeProp(
             isString,
@@ -271,147 +254,141 @@ const configSchema = (config, options) => {
             config.globalHelpers,
             options.globalHelpers
         ),
-    });
+    })
 };
 
-const global = typeof globalThis !== 'undefined' ? globalThis : window || self;
-
-class Cache {
-    #enabled = true
-    #list = {}
-    constructor(config) {
-        this.configure(config);
-    }
-    load(data) {
-        if (this.#enabled) {
-            extend(this.#list, data || {});
-        }
-    }
-    get(key) {
-        if (this.#enabled) {
-            return this.#list[key]
-        }
-    }
-    set(key, value) {
-        if (this.#enabled) {
-            this.#list[key] = value;
+const Template = (options, cache, compiler) => {
+    const config = {
+        path: null,
+        resolver: null
+    };
+    const resolve = (path) => {
+        return config.resolver(config.path, path)
+    };
+    const result = (template, content) => {
+        cache.set(template, content);
+        return content
+    };
+    const compile = (content, template) => {
+        if (isFunction(content)) {
+            return content
+        } else {
+            return compiler.compile(content, template)
         }
-    }
-    exist(key) {
-        if (this.#enabled) {
-            return hasProp(this.#list, key)
+    };
+    const get = (template) => {
+        if (cache.exist(template)) {
+            return cache.resolve(template)
         }
-    }
-    clear() {
-        this.#list = {};
-    }
-    remove(key) {
-        delete this.#list[key];
-    }
-    resolve(key) {
-        return Promise.resolve(this.get(key))
-    }
-    configure(config) {
-        this.#enabled = config.cache;
-        if (isNode() === false) {
-            this.load(global[config.export]);
+        return resolve(template).then((content) =>
+            result(template, compile(content, template))
+        )
+    };
+    const configure = (options) => {
+        config.path = options.path;
+        if (isFunction(options.resolver)) {
+            config.resolver = options.resolver;
         }
+    };
+    configure(options);
+    return {
+        get,
+        configure,
+        compile
     }
-}
+};
 
-class Compiler {
-    #config = {}
-    #symbols = [
-        {
-            symbol: '-',
-            format(value) {
-                return `')\n${this.BUFFER}(${this.SAFE}(${value},1))\n${this.BUFFER}('`
-            },
+const configSymbols = [
+    {
+        symbol: '-',
+        format(value) {
+            return `')\n${this.BUFFER}(${this.SAFE}(${value},1))\n${this.BUFFER}('`
         },
-        {
-            symbol: '=',
-            format(value) {
-                return `')\n${this.BUFFER}(${this.SAFE}(${value}))\n${this.BUFFER}('`
-            },
+    },
+    {
+        symbol: '=',
+        format(value) {
+            return `')\n${this.BUFFER}(${this.SAFE}(${value}))\n${this.BUFFER}('`
         },
-        {
-            symbol: '#',
-            format(value) {
-                return `')\n/**${value}**/\n${this.BUFFER}('`
-            },
+    },
+    {
+        symbol: '#',
+        format(value) {
+            return `')\n/**${value}**/\n${this.BUFFER}('`
         },
-        {
-            symbol: '',
-            format(value) {
-                return `')\n${value.trim()}\n${this.BUFFER}('`
-            },
+    },
+    {
+        symbol: '',
+        format(value) {
+            return `')\n${value.trim()}\n${this.BUFFER}('`
         },
-    ]
-    constructor(config) {
-        this.configure(config);
-    }
-    configure(config) {
-        this.#config.withObject = config.withObject;
-        this.#config.rmWhitespace = config.rmWhitespace;
-        this.#config.token = config.token;
-        this.#config.vars = config.vars;
-        this.#config.globalHelpers = config.globalHelpers;
-        this.#config.matches = [];
-        this.#config.formats = [];
-        this.#config.slurp = {
+    },
+];
+
+const Compiler = (options) => {
+    const config = {};
+    const configure = (options) => {
+        config.withObject = options.withObject;
+        config.rmWhitespace = options.rmWhitespace;
+        config.token = options.token;
+        config.vars = options.vars;
+        config.globalHelpers = options.globalHelpers;
+        config.matches = [];
+        config.formats = [];
+        config.slurp = {
             match: '[s\t\n]*',
-            start: [this.#config.token.start, '_'],
-            end: ['_', this.#config.token.end],
+            start: [config.token.start, '_'],
+            end: ['_', config.token.end],
         };
-        this.#symbols.forEach((item) => {
-            this.#config.matches.push(
-                this.#config.token.start
+        configSymbols.forEach((item) => {
+            config.matches.push(
+                config.token.start
                     .concat(item.symbol)
-                    .concat(this.#config.token.regex)
-                    .concat(this.#config.token.end)
+                    .concat(config.token.regex)
+                    .concat(config.token.end)
             );
-            this.#config.formats.push(item.format.bind(this.#config.vars));
+            config.formats.push(item.format.bind(config.vars));
         });
-        this.#config.regex = new RegExp(
-            this.#config.matches.join('|').concat('|$'),
+        config.regex = new RegExp(
+            config.matches.join('|').concat('|$'),
             'g'
         );
-        this.#config.slurpStart = new RegExp(
-            [this.#config.slurp.match, this.#config.slurp.start.join('')].join(
+        config.slurpStart = new RegExp(
+            [config.slurp.match, config.slurp.start.join('')].join(
                 ''
             ),
             'gm'
         );
-        this.#config.slurpEnd = new RegExp(
-            [this.#config.slurp.end.join(''), this.#config.slurp.match].join(
+        config.slurpEnd = new RegExp(
+            [config.slurp.end.join(''), config.slurp.match].join(
                 ''
             ),
             'gm'
         );
-    }
-    compile(content, path) {
-        const { SCOPE, SAFE, BUFFER, COMPONENT, ELEMENT } = this.#config.vars;
-        const GLOBALS = this.#config.globalHelpers;
-        if (this.#config.rmWhitespace) {
+    };
+    const compile = (content, path) => {
+        const { SCOPE, SAFE, BUFFER, COMPONENT, ELEMENT } = config.vars;
+        const GLOBALS = config.globalHelpers;
+        if (config.rmWhitespace) {
             content = String(content)
                 .replace(/[\r\n]+/g, '\n')
                 .replace(/^\s+|\s+$/gm, '');
         }
         content = String(content)
-            .replace(this.#config.slurpStart, this.#config.token.start)
-            .replace(this.#config.slurpEnd, this.#config.token.end);
+            .replace(config.slurpStart, config.token.start)
+            .replace(config.slurpEnd, config.token.end);
         let source = `${BUFFER}('`;
-        matchTokens(this.#config.regex, content, (params, index, offset) => {
+        matchTokens(config.regex, content, (params, index, offset) => {
             source += symbols(content.slice(index, offset));
             params.forEach((value, index) => {
                 if (value) {
-                    source += this.#config.formats[index](value);
+                    source += config.formats[index](value);
                 }
             });
         });
         source += `');`;
         source = `try{${source}}catch(e){return ${BUFFER}.error(e)}`;
-        if (this.#config.withObject) {
+        if (config.withObject) {
             source = `with(${SCOPE}){${source}}`;
         }
         source = `${BUFFER}.start();${source}return ${BUFFER}.end();`;
@@ -427,50 +404,67 @@ class Compiler {
             throw e
         }
         return result
+    };
+    configure(options);
+    return {
+        configure,
+        compile,
     }
-}
+};
 
-class Template {
-    #path
-    #cache
-    #compiler
-    #resolver
-    constructor(config, cache, compiler) {
-        assertInstanceOf(cache, Cache);
-        assertInstanceOf(compiler, Compiler);
-        this.#cache = cache;
-        this.#compiler = compiler;
-        this.configure(config);
-    }
-    #resolve(path) {
-        return this.#resolver(this.#path, path)
-    }
-    #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)
+const global = typeof globalThis !== 'undefined' ? globalThis : window || self;
+
+const Cache = (options = {}) => {
+    const config = {};
+    const list = {};
+    const load = (data) => {
+        if (config.enabled) {
+            extend(list, data || {});
         }
-    }
-    configure(config) {
-        this.#path = config.path;
-        if (isFunction(config.resolver)) {
-            this.#resolver = config.resolver;
+    };
+    const get = (key) => {
+        if (config.enabled) {
+            return list[key]
         }
-    }
-    get(template) {
-        if (this.#cache.exist(template)) {
-            return this.#cache.resolve(template)
+    };
+    const set = (key, value) => {
+        if (config.enabled) {
+            list[key] = value;
         }
-        return this.#resolve(template).then((content) =>
-            this.#result(template, this.#compile(content, template))
-        )
+    };
+    const exist = (key) => {
+        if (config.enabled) {
+            return hasProp(list, key)
+        }
+    };
+    const clear = () => {
+        Object.keys(list).forEach(remove);
+    };
+    const remove = (key) => {
+        delete list[key];
+    };
+    const resolve = (key) => {
+        return Promise.resolve(get(key))
+    };
+    const configure = (options = {}) => {
+        config.enabled = options.cache;
+        config.export = options.export;
+        if (isNode() === false) {
+            load(global[config.export]);
+        }
+    };
+    configure(options);
+    return {
+        configure,
+        load,
+        set,
+        get,
+        exist,
+        clear,
+        remove,
+        resolve,
     }
-}
+};
 
 const selfClosed = [
     'area',
@@ -517,30 +511,46 @@ const element = (tag, attrs, content) => {
     return result.join('')
 };
 
-class TemplateError extends Error {
-    code = 0
-    constructor(message) {
-        super();
-        this.message = message;
-    }
+/**
+ *
+ * @constructor
+ */
+function TemplateError(){
+    TemplateError.call(this);
+}
+Object.setPrototypeOf(TemplateError.prototype, Error.prototype);
+Object.assign(TemplateError.prototype, {
+    code: 0,
     getCode() {
         return this.code
-    }
+    },
     getMessage() {
         return this.message
-    }
+    },
     toString() {
         return this.getMessage()
     }
-}
+});
 
-class TemplateNotFound extends TemplateError {
-    code = 404
+/**
+ *
+ * @constructor
+ */
+function TemplateNotFound(){
+    TemplateError.call(this);
 }
+Object.setPrototypeOf(TemplateNotFound.prototype, TemplateError.prototype);
+Object.assign(TemplateNotFound.prototype, { code: 404  });
 
-class TemplateSyntaxError extends TemplateError {
-    code = 500
+/**
+ *
+ * @constructor
+ */
+function TemplateSyntaxError(){
+    TemplateError.call(this);
 }
+Object.setPrototypeOf(TemplateSyntaxError.prototype, TemplateError.prototype);
+Object.assign(TemplateSyntaxError.prototype, { code: 500  });
 
 function resolve(list) {
     return Promise.all(list || [])
@@ -599,6 +609,7 @@ const createContextScope = (config, methods) => {
         COMPONENT,
         ELEMENT
     } = config.vars;
+
     /**
      *
      * @type {symbol}
@@ -618,6 +629,7 @@ const createContextScope = (config, methods) => {
             omit(data, [SCOPE, BUFFER, SAFE, COMPONENT, ELEMENT])
         );
     }
+
     Object.assign(ContextScope.prototype, methods);
     Object.defineProperty(ContextScope.prototype, BUFFER, {
         value: createBuffer()
@@ -644,15 +656,15 @@ const createContextScope = (config, methods) => {
     });
     Object.defineProperties(ContextScope.prototype, {
         /** @type {function} */
-        setParentTemplate:{
-            value(value){
+        setParentTemplate: {
+            value(value) {
                 this[PARENT] = value;
                 return this
             }
         },
         /** @type {function} */
         getParentTemplate: {
-            value(){
+            value() {
                 return this[PARENT]
             }
         },
@@ -860,7 +872,7 @@ const createContextScope = (config, methods) => {
         set: {
             value(name, value) {
                 const path = getPath(this, name, false);
-                const result= path.shift();
+                const result = path.shift();
                 const prop = path.pop();
                 if (this.getParentTemplate() && hasProp(result, prop)) {
                     return result[prop]
@@ -900,127 +912,115 @@ const createContextScope = (config, methods) => {
     return ContextScope
 };
 
-class Context {
-    #scope
-
-    constructor(config, methods) {
-        this.configure(config, methods);
-    }
-
-    create(data) {
-        return new this.#scope(data)
-    }
-
-    configure(config, methods) {
-        this.#scope = createContextScope(config, methods);
-    }
-
-    helpers(methods) {
-        extend(this.#scope.prototype, methods || {});
-    }
-}
-
-class EJS {
-    #config = {}
-    #extend = {}
-    #context
-    #compiler
-    #cache
-    #template
-
-    constructor(options) {
-        configSchema(this.#config, options || {});
-        this.#context = new Context(this.#config, this.#extend);
-        this.#compiler = new Compiler(this.#config);
-        this.#cache = new Cache(this.#config);
-        this.#template = new Template(this.#config, this.#cache, this.#compiler);
-        //
-        bindContext(this, ['configure', 'create', 'render', 'require', 'context', 'preload', 'compile', 'helpers']);
-        //
-        this.helpers({ require: this.require, render: this.render });
-    }
-
-    configure(options) {
-        configSchema(this.#config, options || {});
-        this.#context.configure(this.#config, this.#extend);
-        this.#compiler.configure(this.#config);
-        this.#cache.configure(this.#config);
-        this.#template.configure(this.#config);
-        return this.#config
-    }
-
-    filePath(name) {
-        return ext(name, this.#config.extension)
-    }
-
-    require(name) {
-        const scope = this.context({});
-        return this.#output(this.filePath(name), scope).then(() => scope.getMacro())
-    }
-
-    render(name, data) {
-        const scope = this.context(data);
-        return this.#output(this.filePath(name), scope).then(this.outputContent(name, scope))
+const Context = (options, methods) => {
+    /**
+     * @type {InstanceType<ContextScope>}
+     */
+    let Scope;
+    const create = (data) => {
+        return new Scope(data)
+    };
+    const helpers = (methods) => {
+        extend(Scope.prototype, methods || {});
+    };
+    const configure = (options, methods) => {
+        Scope = createContextScope(options, methods);
+    };
+    configure(options, methods);
+    return {
+        configure,
+        create,
+        helpers
     }
+};
 
-    outputContent(name, scope) {
+const EJS = (options = {}) => {
+    const config = configSchema({}, options);
+    const methods = {};
+    const context = Context(config, methods);
+    const compiler = Compiler(config);
+    const cache = Cache(config);
+    const template = Template(config, cache, compiler);
+    const configure = (options = {}) => {
+        configSchema(config, options || {});
+        context.configure(config, methods);
+        compiler.configure(config);
+        cache.configure(config);
+        template.configure(config);
+        return config
+    };
+    const filePath = (name) => {
+        return ext(name, config.extension)
+    };
+    const require = (name) => {
+        const scope = createContext({});
+        return output(filePath(name), scope).then(() => scope.getMacro())
+    };
+    const render = (name, data) => {
+        const scope = createContext(data);
+        return output(filePath(name), scope).then(outputContent(name, scope))
+    };
+    const outputContent = (name, scope) => {
         return (content) => {
             if (scope.getExtend()) {
                 scope.setExtend(false);
-                return this.renderLayout(scope.getLayout(), scope, name)
+                return renderLayout(scope.getLayout(), scope, name)
             }
             return content
         }
-    }
-
-    renderLayout(name, data, parent) {
-        const scope = this.context(data);
+    };
+    const renderLayout = (name, data, parent) => {
+        const scope = createContext(data);
         if (parent) scope.setParentTemplate(parent);
-        return this.#output(this.filePath(name), scope).then(this.outputContent(name, scope))
-    }
-
-    helpers(methods) {
-        this.#context.helpers(extend(this.#extend, methods));
-    }
-
-    context(data) {
-        return this.#context.create(data)
-    }
-
-    compile(content, path) {
-        return this.#compiler.compile(content, path)
-    }
-
-    preload(list) {
-        return this.#cache.load(list || {})
-    }
-
-    create(options) {
-        return new this.constructor(options)
-    }
-
-    #output(path, scope) {
-        const { globalHelpers } = this.#config;
+        return output(filePath(name), scope).then(outputContent(name, scope))
+    };
+    const helpers = (extendMethods) => {
+        context.helpers(extend(methods, extendMethods));
+    };
+    const createContext = (data) => {
+        return context.create(data)
+    };
+    const compile = (content, path) => {
+        return compiler.compile(content, path)
+    };
+    const preload = (list) => {
+        return cache.load(list || {})
+    };
+    const create = (config) => {
+        return EJS(config)
+    };
+    const output = (path, scope) => {
         const params = [scope, scope.useComponent, scope.useElement, scope.getBuffer(), scope.useSafeValue];
-        const globals = globalHelpers
+        const globals = config.globalHelpers
             .filter((name) => isFunction(scope[name]))
             .map((name) => scope[name].bind(scope));
-        return this.#template
+        return template
             .get(path)
             .then((callback) => callback.apply(scope, params.concat(globals)))
+    };
+    helpers({ render, require });
+    return {
+        configure,
+        create,
+        createContext,
+        render,
+        require,
+        preload,
+        compile,
+        helpers
     }
-}
+};
 
 const httpRequest = (path, template) => {
     return fetch(joinPath(path, template)).then(
         (response) => response.text(),
-        (reason) => new TemplateError(reason)
+        (reason) => new TemplateError()
     )
 };
 
-const { render, context, compile, helpers, preload, configure, create } =
-    new EJS({
+const { render, createContext, compile, helpers, preload, configure, create } =
+    EJS({
         resolver: httpRequest,
     });
 
-export { TemplateError, TemplateNotFound, TemplateSyntaxError, compile, configure, context, create, helpers, preload, render };
+export { TemplateError, TemplateNotFound, TemplateSyntaxError, compile, configure, create, createContext, helpers, preload, render };