@kosatyi/ejs 0.0.77 → 0.0.78

package/dist/esm/browser.js

@@ -388,7 +388,7 @@ function Compiler(config) {
             });
         });
         source += `');`;
-        source = `try{${source}}catch(e){console.info(e)}`;
+        source = `try{${source}}catch(e){return ${BUFFER}.error(e)}`;
         if (compiler.withObject) {
             source = `with(${SCOPE}){${source}}`;
         }
@@ -503,10 +503,40 @@ const element = (tag, attrs, content) => {
     return result.join('')
 };
 
+function TemplateError(message) {
+    this.code = 1;
+    this.name = 'TemplateError';
+    this.message = message;
+    Error.call(this);
+}
+Object.setPrototypeOf(TemplateNotFound.prototype, Error.prototype);
+
+function TemplateNotFound(message) {
+    TemplateError.call(this);
+    this.code = 404;
+    this.name = 'TemplateNotFound';
+    this.message = message;
+}
+
+Object.setPrototypeOf(TemplateNotFound.prototype, TemplateError.prototype);
+
+function TemplateSyntaxError(message) {
+    TemplateError.call(this);
+    this.code = 500;
+    this.name = 'TemplateSyntaxError';
+    this.message = message;
+}
+
+Object.setPrototypeOf(TemplateSyntaxError.prototype, TemplateError.prototype);
+
 function resolve(list) {
     return Promise.all(list || []).then((list) => list.join(''))
 }
 
+function reject(error) {
+    return Promise.reject(new TemplateSyntaxError(error.message))
+}
+
 function createBuffer() {
     let store = [],
         array = [];
@@ -526,7 +556,7 @@ function createBuffer() {
         return resolve(result)
     };
     buffer.error = function (e) {
-        throw e
+        return reject(e)
     };
     buffer.end = function () {
         return resolve(array)
@@ -546,7 +576,11 @@ function Context(config) {
         this.helpers = function (methods) {
             extend(Scope.prototype, methods || {});
         };
-
+        /**
+         * @name ContextScope
+         * @param data
+         * @constructor
+         */
         function Scope(data) {
             this[BLOCKS] = {};
             this[MACRO] = {};
@@ -712,8 +746,8 @@ function Context(config) {
                     const prop = path.pop();
                     return hasProp(result, prop) ? result[prop] : defaults
                 },
-                writable: false,
-                configurable: false,
+                writable: true,
+                configurable: true,
                 enumerable: false,
             },
             set: {
@@ -885,27 +919,27 @@ function EJS(options) {
     const cache = new Cache();
     const template = new Template(config, cache, compiler);
 
-    const output = (path, context) => {
+    const output = (path, scope) => {
+        const { globalHelpers } = config;
         const params = [
-            context,
-            context.getComponent(),
-            context.getBuffer(),
+            scope,
+            scope.getComponent(),
+            scope.getBuffer(),
             safeValue,
-        ];
-        config.globalHelpers.forEach((name) => {
-            if (isFunction(context[name]))
-                params.push(context[name].bind(context));
-        });
-        return template.get(path).then(function (callback) {
-            return callback.apply(context, params)
-        })
+        ].concat(
+            globalHelpers
+                .filter((name) => isFunction(scope[name]))
+                .map((name) => scope[name].bind(scope))
+        );
+        return template
+            .get(path)
+            .then((callback) => callback.apply(scope, params))
     };
+
     const require = (name) => {
         const filepath = ext(name, config.extension);
         const scope = context.create({});
-        return output(filepath, scope).then(() => {
-            return scope.getMacro()
-        })
+        return output(filepath, scope).then(() => scope.getMacro())
     };
     const render = (name, data) => {
         const filepath = ext(name, config.extension);
@@ -954,7 +988,7 @@ function EJS(options) {
 const httpRequest = (path, template) => {
     return fetch(joinPath(path, template)).then(
         (response) => response.text(),
-        (reason) => String(reason)
+        (reason) => new TemplateError(reason)
     )
 };
 

package/dist/esm/bundler.js

@@ -0,0 +1,168 @@
+import { promises } from 'fs';
+import { glob } from 'glob';
+import { join, extname, dirname } from 'path';
+import { minify } from 'terser';
+import { configure, compile } from './index.js';
+import babel from '@babel/core';
+
+const isPlainObject = function (obj) {
+    return Object.prototype.toString.call(obj) === '[object Object]'
+};
+
+const extend = (target, ...sources) => {
+    return Object.assign(target, ...sources.filter(isPlainObject))
+};
+
+class Bundler {
+    /**
+     * @type {BundlerOptions}
+     */
+    options = {
+        target: [],
+        transform: true,
+        minify: true,
+        timestamp: true,
+    }
+    /**
+     * @type {EjsConfig}
+     */
+    config = {}
+    constructor(options, config) {
+        extend(this.options, options || {});
+        this.config = configure(config || {});
+        this.templates = {};
+    }
+    stageRead(path) {
+        return promises
+            .readFile(join(this.config.path, path))
+            .then((response) => response.toString())
+    }
+    stageCompile(content, name) {
+        return compile(content, name).source
+    }
+    async stageMinify(content) {
+        if (this.options.minify === false) return content
+        const config = {
+            compress: {
+                dead_code: false,
+                side_effects: false,
+            },
+        };
+        const response = await minify(content, config);
+        return response.code
+    }
+    async stageTransform(content) {
+        if (this.options.transform === false) return content
+        const config = {
+            presets: [['@babel/preset-env']],
+            sourceType: 'script',
+        };
+        const response = await babel.transformAsync(content, config);
+        return response.code
+    }
+    getBundle() {
+        const transform = this.options.transform;
+        const moduleId = this.config.export;
+        const useStrict = this.config.withObject === false;
+        const timestamp = this.options.timestamp;
+        const out = [];
+        if (transform) {
+            out.push('(function(global,factory){');
+            out.push(
+                'typeof exports === "object" && typeof module !== "undefined" ?'
+            );
+            out.push('module.exports = factory():');
+            out.push(
+                'typeof define === "function" && define.amd ? define(factory):'
+            );
+            out.push(
+                '(global = typeof globalThis !== "undefined" ? globalThis:'
+            );
+            out.push('global || self,global["' + moduleId + '"] = factory())');
+            out.push('})(this,(function(){');
+        }
+        if (useStrict) out.push("'use strict'");
+        if (timestamp) out.push('const timestamp = '.concat(String(Date.now())));
+        out.push('const templates = {}');
+        Object.entries(this.templates).forEach(([name, content]) => {
+            name = JSON.stringify(name);
+            content = String(content);
+            out.push(`templates[${name}] = ${content}`);
+        });
+        if (transform) {
+            out.push('return templates');
+            out.push('}))');
+        } else {
+            out.push('export default templates');
+        }
+        return out.join('\n')
+    }
+    async watch() {
+        console.log(`ejs-bundle: watching directory - ${this.config.path}`);
+        try {
+            const watcher = promises.watch(this.config.path, { recursive: true });
+            for await (const { filename } of watcher) {
+                if (extname(filename).slice(1) === this.config.extension) {
+                    console.log(`ejs-bundle: file is changed - ${filename}`);
+                    await this.build();
+                }
+            }
+        } catch (err) {
+            throw err
+        }
+    }
+    async build() {
+        if (this.buildInProgress === true) return false
+        this.buildInProgress = true;
+        await this.concat().catch(console.error);
+        await this.output().catch(console.error);
+        console.log(`ejs-bundle: bundle complete - ${this.options.target}`);
+        this.buildInProgress = false;
+    }
+    async concat() {
+        const pattern = '**/*.'.concat(this.config.extension);
+        const list = await glob(pattern, { cwd: this.config.path });
+        for (let template of list) {
+            let content = '';
+            content = await this.stageRead(template);
+            content = await this.stageCompile(content, template);
+            this.templates[template] = content;
+        }
+    }
+    async output() {
+        const target = [].concat(this.options.target);
+        let content = this.getBundle();
+        if (this.options.transform) {
+            content = await this.stageTransform(content);
+        }
+        if (this.options.minify) {
+            content = await this.stageMinify(content);
+        }
+        for (let file of target) {
+            const folderPath = dirname(file);
+            const folderExists = await promises
+                .stat(folderPath)
+                .then(() => true)
+                .catch(() => false);
+            if (folderExists === false) {
+                await promises.mkdir(folderPath, { recursive: true });
+            }
+            await promises.writeFile(file, content);
+        }
+    }
+}
+
+const ejsBundle = (options, config) => {
+    const bundler = new Bundler(options, config);
+    return {
+        name: 'ejs-bundle',
+        async buildStart() {
+            await bundler.concat();
+        },
+        async buildEnd() {
+            await bundler.output();
+        },
+    }
+};
+
+export { Bundler, ejsBundle };

package/dist/esm/index.js

@@ -391,7 +391,7 @@ function Compiler(config) {
             });
         });
         source += `');`;
-        source = `try{${source}}catch(e){console.info(e)}`;
+        source = `try{${source}}catch(e){return ${BUFFER}.error(e)}`;
         if (compiler.withObject) {
             source = `with(${SCOPE}){${source}}`;
         }
@@ -506,10 +506,40 @@ const element = (tag, attrs, content) => {
     return result.join('')
 };
 
+function TemplateError(message) {
+    this.code = 1;
+    this.name = 'TemplateError';
+    this.message = message;
+    Error.call(this);
+}
+Object.setPrototypeOf(TemplateNotFound.prototype, Error.prototype);
+
+function TemplateNotFound(message) {
+    TemplateError.call(this);
+    this.code = 404;
+    this.name = 'TemplateNotFound';
+    this.message = message;
+}
+
+Object.setPrototypeOf(TemplateNotFound.prototype, TemplateError.prototype);
+
+function TemplateSyntaxError(message) {
+    TemplateError.call(this);
+    this.code = 500;
+    this.name = 'TemplateSyntaxError';
+    this.message = message;
+}
+
+Object.setPrototypeOf(TemplateSyntaxError.prototype, TemplateError.prototype);
+
 function resolve(list) {
     return Promise.all(list || []).then((list) => list.join(''))
 }
 
+function reject(error) {
+    return Promise.reject(new TemplateSyntaxError(error.message))
+}
+
 function createBuffer() {
     let store = [],
         array = [];
@@ -529,7 +559,7 @@ function createBuffer() {
         return resolve(result)
     };
     buffer.error = function (e) {
-        throw e
+        return reject(e)
     };
     buffer.end = function () {
         return resolve(array)
@@ -549,7 +579,11 @@ function Context(config) {
         this.helpers = function (methods) {
             extend(Scope.prototype, methods || {});
         };
-
+        /**
+         * @name ContextScope
+         * @param data
+         * @constructor
+         */
         function Scope(data) {
             this[BLOCKS] = {};
             this[MACRO] = {};
@@ -715,8 +749,8 @@ function Context(config) {
                     const prop = path.pop();
                     return hasProp(result, prop) ? result[prop] : defaults
                 },
-                writable: false,
-                configurable: false,
+                writable: true,
+                configurable: true,
                 enumerable: false,
             },
             set: {
@@ -888,27 +922,27 @@ function EJS(options) {
     const cache = new Cache();
     const template = new Template(config, cache, compiler);
 
-    const output = (path, context) => {
+    const output = (path, scope) => {
+        const { globalHelpers } = config;
         const params = [
-            context,
-            context.getComponent(),
-            context.getBuffer(),
+            scope,
+            scope.getComponent(),
+            scope.getBuffer(),
             safeValue,
-        ];
-        config.globalHelpers.forEach((name) => {
-            if (isFunction(context[name]))
-                params.push(context[name].bind(context));
-        });
-        return template.get(path).then(function (callback) {
-            return callback.apply(context, params)
-        })
+        ].concat(
+            globalHelpers
+                .filter((name) => isFunction(scope[name]))
+                .map((name) => scope[name].bind(scope))
+        );
+        return template
+            .get(path)
+            .then((callback) => callback.apply(scope, params))
     };
+
     const require = (name) => {
         const filepath = ext(name, config.extension);
         const scope = context.create({});
-        return output(filepath, scope).then(() => {
-            return scope.getMacro()
-        })
+        return output(filepath, scope).then(() => scope.getMacro())
     };
     const render = (name, data) => {
         const filepath = ext(name, config.extension);
@@ -958,7 +992,7 @@ function readFile(path, template) {
     return new Promise((resolve, reject) => {
         fs.readFile(joinPath(path, template), (error, data) => {
             if (error) {
-                reject(error);
+                reject(new TemplateError(error));
             } else {
                 resolve(data.toString());
             }

package/dist/esm/worker.js

@@ -382,7 +382,7 @@ function Compiler(config) {
             });
         });
         source += `');`;
-        source = `try{${source}}catch(e){console.info(e)}`;
+        source = `try{${source}}catch(e){return ${BUFFER}.error(e)}`;
         if (compiler.withObject) {
             source = `with(${SCOPE}){${source}}`;
         }
@@ -497,10 +497,40 @@ const element = (tag, attrs, content) => {
     return result.join('')
 };
 
+function TemplateError(message) {
+    this.code = 1;
+    this.name = 'TemplateError';
+    this.message = message;
+    Error.call(this);
+}
+Object.setPrototypeOf(TemplateNotFound.prototype, Error.prototype);
+
+function TemplateNotFound(message) {
+    TemplateError.call(this);
+    this.code = 404;
+    this.name = 'TemplateNotFound';
+    this.message = message;
+}
+
+Object.setPrototypeOf(TemplateNotFound.prototype, TemplateError.prototype);
+
+function TemplateSyntaxError(message) {
+    TemplateError.call(this);
+    this.code = 500;
+    this.name = 'TemplateSyntaxError';
+    this.message = message;
+}
+
+Object.setPrototypeOf(TemplateSyntaxError.prototype, TemplateError.prototype);
+
 function resolve(list) {
     return Promise.all(list || []).then((list) => list.join(''))
 }
 
+function reject(error) {
+    return Promise.reject(new TemplateSyntaxError(error.message))
+}
+
 function createBuffer() {
     let store = [],
         array = [];
@@ -520,7 +550,7 @@ function createBuffer() {
         return resolve(result)
     };
     buffer.error = function (e) {
-        throw e
+        return reject(e)
     };
     buffer.end = function () {
         return resolve(array)
@@ -540,7 +570,11 @@ function Context(config) {
         this.helpers = function (methods) {
             extend(Scope.prototype, methods || {});
         };
-
+        /**
+         * @name ContextScope
+         * @param data
+         * @constructor
+         */
         function Scope(data) {
             this[BLOCKS] = {};
             this[MACRO] = {};
@@ -706,8 +740,8 @@ function Context(config) {
                     const prop = path.pop();
                     return hasProp(result, prop) ? result[prop] : defaults
                 },
-                writable: false,
-                configurable: false,
+                writable: true,
+                configurable: true,
                 enumerable: false,
             },
             set: {
@@ -879,27 +913,27 @@ function EJS(options) {
     const cache = new Cache();
     const template = new Template(config, cache, compiler);
 
-    const output = (path, context) => {
+    const output = (path, scope) => {
+        const { globalHelpers } = config;
         const params = [
-            context,
-            context.getComponent(),
-            context.getBuffer(),
+            scope,
+            scope.getComponent(),
+            scope.getBuffer(),
             safeValue,
-        ];
-        config.globalHelpers.forEach((name) => {
-            if (isFunction(context[name]))
-                params.push(context[name].bind(context));
-        });
-        return template.get(path).then(function (callback) {
-            return callback.apply(context, params)
-        })
+        ].concat(
+            globalHelpers
+                .filter((name) => isFunction(scope[name]))
+                .map((name) => scope[name].bind(scope))
+        );
+        return template
+            .get(path)
+            .then((callback) => callback.apply(scope, params))
     };
+
     const require = (name) => {
         const filepath = ext(name, config.extension);
         const scope = context.create({});
-        return output(filepath, scope).then(() => {
-            return scope.getMacro()
-        })
+        return output(filepath, scope).then(() => scope.getMacro())
     };
     const render = (name, data) => {
         const filepath = ext(name, config.extension);
@@ -945,22 +979,56 @@ function EJS(options) {
     return this
 }
 
-const templates = {};
+const templateCache = {};
+
 const ejs = new EJS({
     cache: false,
     withObject: false,
     resolver(path, name) {
-        if (name in templates) {
-            return Promise.resolve(templates[name])
-        }
-        return Promise.resolve(['template not found', name])
+        return new Promise((resolve, reject) => {
+            if (templateCache.hasOwnProperty(name)) {
+                resolve(templateCache[name]);
+            } else {
+                reject(new TemplateNotFound(`template ${name} not found`));
+            }
+        })
     },
 });
 
-async function useTemplates(list) {
-    Object.assign(templates, list || {});
+const getOrigin = (url, secure) => {
+    url = new URL(url);
+    if (secure) url.protocol = 'https:';
+    return url.origin
+};
+
+function setTemplates(list) {
+    Object.assign(templateCache, list || {});
+}
+
+/**
+ * @typedef {Object<string,any>} HonoContext
+ * @property {function(*):Promise<Response>} html
+ * @property {function(name:string,data:{}):Promise<string>} render
+ * @property {function(name:string,data:{}):Promise<string>} ejs
+ * @property {ContextScope} data
+ */
+
+/**
+ *
+ * @param {Object<string,any>} options
+ * @return {(function(c:Context, next): Promise<any>)|*}
+ */
+function setRenderer({ secure = true, version = '1.0' }) {
+    return async (c, next) => {
+        c.data = context({});
+        c.data.set('version', version);
+        c.data.set('origin', getOrigin(c.req.url, secure));
+        c.ejs = (name, data) => render(name, Object.assign({}, c.data, data));
+        c.render = (name, data) => c.html(c.ejs(name, data));
+        await next();
+    }
 }
 
 const { render, context, compile, helpers, preload, configure, create } = ejs;
 
-export { compile, configure, context, create, helpers, preload, render, useTemplates };
+export { compile, configure, context, create, helpers, preload, render, setRenderer, setTemplates };