@kosatyi/ejs 0.0.110 → 0.0.111

package/dist/esm/worker.js

@@ -383,10 +383,10 @@ class EjsCompiler {
             const result = Function.apply(null, params.concat(OUTPUT));
             result.source = `(function(${params.join(',')}){\n${OUTPUT}\n});`;
             return result
-        } catch (error) {
-            error.filename = path;
-            error.source = OUTPUT;
-            throw error
+        } catch (e) {
+            e.filename = path;
+            e.source = OUTPUT;
+            error(0, e);
         }
     }
 }
@@ -498,13 +498,11 @@ const element = (tag, attrs, content) => {
 const resolve = (list) => {
     return Promise.all(list || [])
         .then((list) => list.join(''))
-        .catch((e) => {
-            return error(500, e)
-        })
+        .catch((e) => error(0, e))
 };
 
 const reject = (e) => {
-    return Promise.reject(error(500, e))
+    return Promise.reject(error(0, e))
 };
 
 const EjsBuffer = () => {
@@ -542,6 +540,7 @@ const EjsBuffer = () => {
 const PARENT = Symbol('EjsContext.parentTemplate');
 
 const createContext$1 = (config, methods) => {
+    const globals = config.globals || [];
     const {
         BLOCKS,
         MACRO,
@@ -553,40 +552,41 @@ const createContext$1 = (config, methods) => {
         COMPONENT,
         ELEMENT,
     } = config.vars;
-    const globals = config.globals || [];
-    function EjsContext(data) {
-        this[PARENT] = null;
-        this[BLOCKS] = {};
-        this[MACRO] = {};
-        Object.assign(
-            this,
-            omit(data, [SCOPE, BUFFER, SAFE, COMPONENT, ELEMENT]),
-        );
+    class Context {
+        constructor(data) {
+            this[PARENT] = null;
+            this[BLOCKS] = {};
+            this[MACRO] = {};
+            Object.assign(
+                this,
+                omit(data, [SCOPE, BUFFER, SAFE, COMPONENT, ELEMENT]),
+            );
+        }
     }
-    Object.defineProperty(EjsContext.prototype, BUFFER, {
-        value: EjsBuffer(),
-    });
-    Object.defineProperty(EjsContext.prototype, BLOCKS, {
-        value: {},
-        writable: true,
-    });
-    Object.defineProperty(EjsContext.prototype, MACRO, {
-        value: {},
-        writable: true,
-    });
-    Object.defineProperty(EjsContext.prototype, LAYOUT, {
-        value: false,
-        writable: true,
-    });
-    Object.defineProperty(EjsContext.prototype, EXTEND, {
-        value: false,
-        writable: true,
-    });
-    Object.defineProperty(EjsContext.prototype, PARENT, {
-        value: null,
-        writable: true,
-    });
-    Object.defineProperties(EjsContext.prototype, {
+    Object.defineProperties(Context.prototype, {
+        [BUFFER]: {
+            value: EjsBuffer(),
+        },
+        [BLOCKS]: {
+            value: {},
+            writable: true,
+        },
+        [MACRO]: {
+            value: {},
+            writable: true,
+        },
+        [LAYOUT]: {
+            value: false,
+            writable: true,
+        },
+        [EXTEND]: {
+            value: false,
+            writable: true,
+        },
+        [PARENT]: {
+            value: null,
+            writable: true,
+        },
         setParentTemplate: {
             value(value) {
                 this[PARENT] = value;
@@ -599,32 +599,34 @@ const createContext$1 = (config, methods) => {
             },
         },
         useEscapeValue: {
-            get: () => escapeValue,
+            value() {
+                return escapeValue
+            },
         },
         useComponent: {
-            get() {
+            value() {
                 if (isFunction(this[COMPONENT])) {
                     return this[COMPONENT].bind(this)
                 } else {
                     return function () {
-                        throw new Error(`${COMPONENT} must be a function`)
+                        error(2, `${COMPONENT} must be a function`);
                     }
                 }
             },
         },
         useElement: {
-            get() {
+            value() {
                 if (isFunction(this[ELEMENT])) {
                     return this[ELEMENT].bind(this)
                 } else {
                     return () => {
-                        throw new Error(`${ELEMENT} must be a function`)
+                        error(2, `${ELEMENT} must be a function`);
                     }
                 }
             },
         },
         useBuffer: {
-            get() {
+            value() {
                 return this[BUFFER]
             },
         },
@@ -677,17 +679,18 @@ const createContext$1 = (config, methods) => {
         },
         echo: {
             value() {
-                return [].slice.call(arguments).forEach(this.useBuffer)
+                return [].slice.call(arguments).forEach(this.useBuffer())
             },
         },
         fn: {
             value(callback) {
+                const buffer = this.useBuffer();
                 const context = this;
                 return function () {
                     if (isFunction(callback)) {
-                        context.useBuffer.backup();
-                        context.useBuffer(callback.apply(context, arguments));
-                        return context.useBuffer.restore()
+                        buffer.backup();
+                        buffer(callback.apply(context, arguments));
+                        return buffer.restore()
                     }
                 }
             },
@@ -804,14 +807,22 @@ const createContext$1 = (config, methods) => {
             value() {},
             writable: true,
         },
+        require: {
+            value() {},
+            writable: true,
+        },
+        render: {
+            value() {},
+            writable: true,
+        },
     });
     Object.entries(methods).forEach(([name, value]) => {
         if (isFunction(value) && globals.includes(name)) {
-            value = value.bind(EjsContext.prototype);
+            value = value.bind(Context.prototype);
         }
-        EjsContext.prototype[name] = value;
+        Context.prototype[name] = value;
     });
-    return EjsContext
+    return Context
 };
 
 class EjsContext {
@@ -849,6 +860,10 @@ class EjsInstance {
         'compile',
         'helpers',
     ]
+    /**
+     *
+     * @param {EjsConfig} options
+     */
     constructor(options = {}) {
         bindContext(this, this.constructor.exports);
         this.#methods = {};
@@ -911,10 +926,10 @@ class EjsInstance {
             .then((callback) =>
                 callback.apply(data, [
                     data,
-                    data.useComponent,
-                    data.useElement,
-                    data.useBuffer,
-                    data.useEscapeValue,
+                    data.useComponent(),
+                    data.useElement(),
+                    data.useBuffer(),
+                    data.useEscapeValue(),
                 ]),
             )
     }
@@ -936,9 +951,6 @@ class EjsInstance {
     }
 }
 
-/**
- * @type {{[p:string]:Function}}
- */
 const templateCache = {};
 
 const getOrigin = (url, secure) => {
@@ -947,37 +959,23 @@ const getOrigin = (url, secure) => {
     return url.origin
 };
 
+const resolver = async (path, name, error) => {
+    if (isFunction(templateCache[name])) {
+        return templateCache[name]
+    }
+    error(1, `template ${name} not found`);
+};
+
 const { render, createContext, helpers, configure } = new EjsInstance({
     cache: false,
     strict: true,
-    async resolver(path, name, error) {
-        if (isFunction(templateCache[name])) {
-            return templateCache[name]
-        }
-        error(404, `template ${name} not found`);
-    },
+    resolver,
 });
 
-/**
- * @param {{[p:string],Function}} templates
- */
 function useTemplates(templates = {}) {
     Object.assign(templateCache, templates);
 }
 
-/**
- * @typedef {{[p:string]:any}} HonoContext
- * @property {function(*):Promise<Response>} html
- * @property {function():Promise<Response>} notFound
- * @property {function(methods:{}):void} helpers
- * @property {function(name:string,data:{}):Promise<string>} render
- * @property {function(name:string,data:{}):Promise<string>} ejs
- * @property {EjsContext} data
- */
-/**
- * @param {RendererParams} options
- * @return {(function(c:HonoContext, next): Promise<any>)|*}
- */
 function useRenderer(options = {}) {
     useTemplates(options.templates ?? {});
     return async (c, next) => {