@kosatyi/ejs 0.0.108 → 0.0.110

package/dist/esm/worker.js

@@ -149,7 +149,7 @@ const symbols = (string) => {
     )
 };
 
-const safeValue = (value, escape) => {
+const escapeValue = (value, escape) => {
     const check = value;
     return check == null
         ? ''
@@ -209,12 +209,27 @@ const bindContext = (object, methods = []) => {
     }
 };
 
-class Template {
+class EjsError extends Error {
+    constructor(code, content) {
+        super(content);
+        this.code = code;
+        if (content instanceof Error) {
+            this.stack = content.stack;
+            this.message = content.message;
+        }
+    }
+}
+
+const error = (code, content) => {
+    throw new EjsError(code, content)
+};
+
+class EjsTemplate {
     #path
     #resolver
     #cache
     #compiler
-    static exports = ['configure', 'get', 'compile']
+    static exports = ['configure', 'get']
     constructor(options, cache, compiler) {
         bindContext(this, this.constructor.exports);
         this.#cache = cache;
@@ -230,11 +245,13 @@ class Template {
     #resolve(template) {
         const cached = this.#cache.get(template);
         if (cached instanceof Promise) return cached
-        const result = Promise.resolve(this.#resolver(this.#path, template));
+        const result = Promise.resolve(
+            this.#resolver(this.#path, template, error),
+        );
         this.#cache.set(template, result);
         return result
     }
-    compile(content, template) {
+    #compile(content, template) {
         const cached = this.#cache.get(template);
         if (typeof cached === 'function') return cached
         if (typeof content === 'string') {
@@ -246,9 +263,9 @@ class Template {
         }
     }
     get(template) {
-        return this.#resolve(template).then((content) =>
-            this.compile(content, template),
-        )
+        return this.#resolve(template).then((content) => {
+            return this.#compile(content, template)
+        })
     }
 }
 
@@ -271,15 +288,13 @@ const tokensMatch = (regex, content, callback) => {
     });
 };
 
-class Compiler {
+class EjsCompiler {
     #config = {}
-    static exports = ['compile']
-
+    static exports = ['configure', 'compile']
     constructor(options) {
         bindContext(this, this.constructor.exports);
         this.configure(options);
     }
-
     configure(options) {
         this.#config.strict = options.strict;
         this.#config.rmWhitespace = options.rmWhitespace;
@@ -354,7 +369,7 @@ class Compiler {
             });
         });
         OUTPUT += `');`;
-        OUTPUT = `try{${OUTPUT}}catch(e){return ${BUFFER}.error(e,'${path}')}`;
+        OUTPUT = `try{${OUTPUT}}catch(e){return ${BUFFER}.error(e)}`;
         if (this.#config.strict === false) {
             OUTPUT = `with(${SCOPE}){${OUTPUT}}`;
         }
@@ -376,7 +391,7 @@ class Compiler {
     }
 }
 
-class Cache {
+class EjsCache {
     static exports = [
         'load',
         'set',
@@ -417,13 +432,11 @@ class Cache {
     resolve(key) {
         return Promise.resolve(this.get(key))
     }
-
     load(data) {
         if (this.#cache) {
             Object.assign(this.#list, data || {});
         }
     }
-
     configure(options) {
         this.#cache = options.cache;
         this.#precompiled = options.precompiled;
@@ -482,36 +495,16 @@ const element = (tag, attrs, content) => {
     return result.join('')
 };
 
-class TemplateError extends Error {
-    name = 'TemplateError'
-    constructor(error) {
-        super(error);
-        if (error instanceof Error) {
-            this.stack = error.stack;
-            this.filename = error.filename;
-            this.lineno = error.lineno;
-        }
-    }
-}
-
-class TemplateNotFound extends TemplateError {
-    name = 'TemplateNotFound'
-    code = 404
-}
-
-class TemplateSyntaxError extends TemplateError {
-    name = 'TemplateSyntaxError'
-    code = 500
-}
-
 const resolve = (list) => {
     return Promise.all(list || [])
         .then((list) => list.join(''))
-        .catch((e) => e)
+        .catch((e) => {
+            return error(500, e)
+        })
 };
 
-const reject = (error) => {
-    return Promise.reject(new TemplateSyntaxError(error))
+const reject = (e) => {
+    return Promise.reject(error(500, e))
 };
 
 const EjsBuffer = () => {
@@ -537,7 +530,7 @@ const EjsBuffer = () => {
         array = store.pop();
         return resolve(result)
     };
-    EjsBuffer.error = (e, filename) => {
+    EjsBuffer.error = (e) => {
         return reject(e)
     };
     EjsBuffer.end = () => {
@@ -570,12 +563,6 @@ const createContext$1 = (config, methods) => {
             omit(data, [SCOPE, BUFFER, SAFE, COMPONENT, ELEMENT]),
         );
     }
-    Object.entries(methods).forEach(([name, value]) => {
-        if (isFunction(value) && globals.includes(name)) {
-            value = value.bind(EjsContext.prototype);
-        }
-        EjsContext.prototype[name] = value;
-    });
     Object.defineProperty(EjsContext.prototype, BUFFER, {
         value: EjsBuffer(),
     });
@@ -600,36 +587,31 @@ const createContext$1 = (config, methods) => {
         writable: true,
     });
     Object.defineProperties(EjsContext.prototype, {
-        /** @type {function} */
         setParentTemplate: {
             value(value) {
                 this[PARENT] = value;
                 return this
             },
         },
-        /** @type {function} */
         getParentTemplate: {
             value() {
                 return this[PARENT]
             },
         },
-        /** @type {function} */
-        useSafeValue: {
-            get: () => safeValue,
+        useEscapeValue: {
+            get: () => escapeValue,
         },
-        /** @type {function} */
         useComponent: {
             get() {
                 if (isFunction(this[COMPONENT])) {
                     return this[COMPONENT].bind(this)
                 } else {
-                    return () => {
+                    return function () {
                         throw new Error(`${COMPONENT} must be a function`)
                     }
                 }
             },
         },
-        /** @type {function} */
         useElement: {
             get() {
                 if (isFunction(this[ELEMENT])) {
@@ -641,51 +623,43 @@ const createContext$1 = (config, methods) => {
                 }
             },
         },
-        /** @type {function} */
         useBuffer: {
             get() {
                 return this[BUFFER]
             },
         },
-        /** @type {function} */
         getMacro: {
             value() {
                 return this[MACRO]
             },
         },
-        /** @type {function} */
         getBlocks: {
             value() {
                 return this[BLOCKS]
             },
         },
-        /** @type {function} */
         setExtend: {
             value(value) {
                 this[EXTEND] = value;
                 return this
             },
         },
-        /** @type {function} */
         getExtend: {
             value() {
                 return this[EXTEND]
             },
         },
-        /** @type {function} */
         setLayout: {
             value(layout) {
                 this[LAYOUT] = layout;
                 return this
             },
         },
-        /** @type {function} */
         getLayout: {
             value() {
                 return this[LAYOUT]
             },
         },
-        /** @type {function} */
         clone: {
             value(exclude_blocks) {
                 const filter = [LAYOUT, EXTEND, BUFFER];
@@ -695,32 +669,29 @@ const createContext$1 = (config, methods) => {
                 return omit(this, filter)
             },
         },
-        /** @type {function} */
         extend: {
             value(layout) {
                 this.setExtend(true);
                 this.setLayout(layout);
             },
         },
-        /** @type {function} */
         echo: {
             value() {
                 return [].slice.call(arguments).forEach(this.useBuffer)
             },
         },
-        /** @type {function} */
         fn: {
             value(callback) {
-                return () => {
+                const context = this;
+                return function () {
                     if (isFunction(callback)) {
-                        this.useBuffer.backup();
-                        this.useBuffer(callback.apply(this, arguments));
-                        return this.useBuffer.restore()
+                        context.useBuffer.backup();
+                        context.useBuffer(callback.apply(context, arguments));
+                        return context.useBuffer.restore()
                     }
                 }
             },
         },
-        /** @type {function} */
         macro: {
             value(name, callback) {
                 const list = this.getMacro();
@@ -731,7 +702,6 @@ const createContext$1 = (config, methods) => {
                 };
             },
         },
-        /** @type {function} */
         call: {
             value(name) {
                 const list = this.getMacro();
@@ -742,35 +712,35 @@ const createContext$1 = (config, methods) => {
                 }
             },
         },
-        /** @type {function} */
         block: {
             value(name, callback) {
                 const blocks = this.getBlocks();
                 blocks[name] = blocks[name] || [];
                 blocks[name].push(this.fn(callback));
                 if (this.getExtend()) return
+                const context = this;
                 const list = Object.assign([], blocks[name]);
-                const shift = () => list.shift();
-                const next = () => {
+                const shift = function () {
+                    return list.shift()
+                };
+                const next = function () {
                     const parent = shift();
                     if (parent) {
-                        return () => {
-                            this.echo(parent(next()));
+                        return function () {
+                            context.echo(parent(next()));
                         }
                     } else {
-                        return () => {}
+                        return function () {}
                     }
                 };
                 this.echo(shift()(next()));
             },
         },
-        /** @type {function} */
         hasBlock: {
             value(name) {
                 return this.getBlocks().hasOwnProperty(name)
             },
         },
-        /** @type {function} */
         include: {
             value(path, data, cx) {
                 const context = cx === false ? {} : this.clone(true);
@@ -779,7 +749,6 @@ const createContext$1 = (config, methods) => {
                 this.echo(promise);
             },
         },
-        /** @type {function} */
         use: {
             value(path, namespace) {
                 this.echo(
@@ -792,13 +761,6 @@ const createContext$1 = (config, methods) => {
                 );
             },
         },
-        /** @type {function} */
-        async: {
-            value(promise, callback) {
-                this.echo(Promise.resolve(promise).then(callback));
-            },
-        },
-        /** @type {function} */
         get: {
             value(name, defaults) {
                 const path = getPath(this, name, true);
@@ -807,7 +769,6 @@ const createContext$1 = (config, methods) => {
                 return hasProp(result, prop) ? result[prop] : defaults
             },
         },
-        /** @type {function} */
         set: {
             value(name, value) {
                 const path = getPath(this, name, false);
@@ -819,7 +780,6 @@ const createContext$1 = (config, methods) => {
                 return (result[prop] = value)
             },
         },
-        /** @type {function} */
         each: {
             value(object, callback) {
                 if (isString(object)) {
@@ -829,7 +789,6 @@ const createContext$1 = (config, methods) => {
             },
             writable: true,
         },
-        /** @type {function} */
         el: {
             value(tag, attr, content) {
                 content = isFunction(content) ? this.fn(content)() : content;
@@ -841,16 +800,21 @@ const createContext$1 = (config, methods) => {
             },
             writable: true,
         },
-        /** @type {function} */
         ui: {
-            value(layout) {},
+            value() {},
             writable: true,
         },
     });
+    Object.entries(methods).forEach(([name, value]) => {
+        if (isFunction(value) && globals.includes(name)) {
+            value = value.bind(EjsContext.prototype);
+        }
+        EjsContext.prototype[name] = value;
+    });
     return EjsContext
 };
 
-class Context {
+class EjsContext {
     #context
     static exports = ['create', 'globals', 'helpers']
     constructor(options, methods) {
@@ -889,10 +853,14 @@ class EjsInstance {
         bindContext(this, this.constructor.exports);
         this.#methods = {};
         this.#config = configSchema({}, options);
-        this.#context = new Context(this.#config, this.#methods);
-        this.#compiler = new Compiler(this.#config);
-        this.#cache = new Cache(this.#config);
-        this.#template = new Template(this.#config, this.#cache, this.#compiler);
+        this.#context = new EjsContext(this.#config, this.#methods);
+        this.#compiler = new EjsCompiler(this.#config);
+        this.#cache = new EjsCache(this.#config);
+        this.#template = new EjsTemplate(
+            this.#config,
+            this.#cache,
+            this.#compiler,
+        );
         this.helpers({ render: this.render, require: this.require });
     }
     create(options) {
@@ -946,7 +914,7 @@ class EjsInstance {
                     data.useComponent,
                     data.useElement,
                     data.useBuffer,
-                    data.useSafeValue,
+                    data.useEscapeValue,
                 ]),
             )
     }
@@ -982,12 +950,11 @@ const getOrigin = (url, secure) => {
 const { render, createContext, helpers, configure } = new EjsInstance({
     cache: false,
     strict: true,
-    async resolver(path, name) {
+    async resolver(path, name, error) {
         if (isFunction(templateCache[name])) {
             return templateCache[name]
-        } else {
-            throw new TemplateNotFound(`template ${name} not found`)
         }
+        error(404, `template ${name} not found`);
     },
 });
 
@@ -1027,4 +994,4 @@ function useRenderer(options = {}) {
     }
 }
 
-export { TemplateError, TemplateNotFound, TemplateSyntaxError, configure, createContext, helpers, render, useRenderer, useTemplates };
+export { configure, createContext, helpers, render, useRenderer, useTemplates };