@kosatyi/ejs 0.0.110 → 0.0.112

package/dist/esm/browser.js

@@ -389,10 +389,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);
         }
     }
 }
@@ -504,13 +504,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 = () => {
@@ -548,6 +546,7 @@ const EjsBuffer = () => {
 const PARENT = Symbol('EjsContext.parentTemplate');
 
 const createContext$1 = (config, methods) => {
+    const globals = config.globals || [];
     const {
         BLOCKS,
         MACRO,
@@ -559,40 +558,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;
@@ -605,32 +605,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]
             },
         },
@@ -683,17 +685,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()
                     }
                 }
             },
@@ -810,14 +813,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 {
@@ -855,6 +866,10 @@ class EjsInstance {
         'compile',
         'helpers',
     ]
+    /**
+     *
+     * @param {EjsConfig} options
+     */
     constructor(options = {}) {
         bindContext(this, this.constructor.exports);
         this.#methods = {};
@@ -917,10 +932,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(),
                 ]),
             )
     }
@@ -942,13 +957,13 @@ class EjsInstance {
     }
 }
 
-const httpRequest = (path, template, error) => {
+const resolver = async (path, template, error) => {
     return fetch(joinPath(path, template)).then(
         (response) => {
             if (response.ok) return response.text()
-            return error(404, `template ${template} not found`)
+            return error(1, `template ${template} not found`)
         },
-        (reason) => error(500, reason),
+        (reason) => error(0, reason),
     )
 };
 
@@ -961,7 +976,7 @@ const {
     compile,
     preload,
 } = new EjsInstance({
-    resolver: httpRequest,
+    resolver,
 });
 
-export { compile, configure, create, createContext, helpers, preload, render };
+export { compile, configure, create, createContext, element, escapeValue, helpers, preload, render };

package/dist/esm/bundler.js

@@ -1,8 +1,8 @@
 import fs from 'node:fs/promises';
 import globWatch from 'glob-watcher';
 import { join, dirname } from 'node:path';
-import { create } from './index.js';
 import { glob } from 'glob';
+import { create } from './index.js';
 
 const symbolEntities = {
     "'": "'",
@@ -49,6 +49,7 @@ class EjsBundler {
     #ejsOptions
     #buildInProgress
     static exports = ['build', 'watch', 'concat', 'output']
+
     constructor(bundlerOptions = {}, ejsOptions = {}) {
         bindContext(this, this.constructor.exports);
         const { compile, configure } = create(ejsOptions);
@@ -58,14 +59,17 @@ class EjsBundler {
         this.#buildInProgress = false;
         this.#templates = {};
     }
+
     async #stageRead(path) {
         return fs
             .readFile(join(this.#ejsOptions.path, path))
             .then((response) => response.toString())
     }
+
     #stageCompile(content, name) {
         return this.#compile(content, name).source
     }
+
     #getBundle() {
         const umd = this.#bundlerOptions.umd;
         const strict = this.#ejsOptions.strict;
@@ -100,6 +104,7 @@ class EjsBundler {
         }
         return out.join('\n')
     }
+
     async build() {
         if (this.#buildInProgress === true) return false
         this.#buildInProgress = true;
@@ -108,6 +113,7 @@ class EjsBundler {
         console.log('✅', 'bundle complete:', this.#bundlerOptions.target);
         this.#buildInProgress = false;
     }
+
     async watch() {
         console.log('🔍', 'watch directory:', this.#ejsOptions.path);
         const pattern = '**/*.'.concat(this.#ejsOptions.extension);
@@ -128,6 +134,7 @@ class EjsBundler {
             });
         });
     }
+
     async concat() {
         const pattern = '**/*.'.concat(this.#ejsOptions.extension);
         const list = await glob(
@@ -142,6 +149,7 @@ class EjsBundler {
             this.#templates[template] = content;
         }
     }
+
     async output() {
         const target = [].concat(this.#bundlerOptions.target);
         const content = this.#getBundle();