@kosatyi/ejs 0.0.77 → 0.0.78

package/bin/bundler.js

@@ -0,0 +1,43 @@
+#! /usr/bin/env node
+
+import argv from 'process.argv'
+
+import { Bundler } from '../dist/esm/bundler.js'
+
+const schema = argv(process.argv.slice(2))
+
+const params = schema({
+    target: null,
+    transform: false,
+    timestamp: true,
+    minify: false,
+    withObject: false,
+    export: 'ejsPrecompiled',
+    path: 'views',
+    extension: 'ejs',
+})
+
+if (typeof params.target !== 'string') {
+    throw new Error('target is not a string')
+}
+
+const options = {
+    target: params.target,
+    transform: params.transform,
+    timestamp: params.timestamp,
+    minify: params.minify,
+}
+const config = {
+    withObject: params.withObject,
+    path: params.path,
+    export: params.export,
+    extension: params.extension,
+}
+
+const bundler = new Bundler(options, config)
+
+await bundler.build()
+
+if (params.watch && params.path) {
+    await bundler.watch()
+}

package/dist/cjs/browser.js

@@ -323,7 +323,7 @@ function Compiler(config) {
       });
     });
     source += "');";
-    source = "try{".concat(source, "}catch(e){console.info(e)}");
+    source = "try{".concat(source, "}catch(e){return ").concat(BUFFER, ".error(e)}");
     if (compiler.withObject) {
       source = "with(".concat(SCOPE, "){").concat(source, "}");
     }
@@ -435,11 +435,36 @@ var element = function 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(function (list) {
     return list.join('');
   });
 }
+function reject(error) {
+  return Promise.reject(new TemplateSyntaxError(error.message));
+}
 function createBuffer() {
   var store = [],
     array = [];
@@ -459,7 +484,7 @@ function createBuffer() {
     return resolve(result);
   };
   buffer.error = function (e) {
-    throw e;
+    return reject(e);
   };
   buffer.end = function () {
     return resolve(array);
@@ -484,6 +509,11 @@ function Context(config) {
     this.helpers = function (methods) {
       extend(Scope.prototype, methods || {});
     };
+    /**
+     * @name ContextScope
+     * @param data
+     * @constructor
+     */
     function Scope(data) {
       this[BLOCKS] = {};
       this[MACRO] = {};
@@ -629,8 +659,8 @@ function Context(config) {
         var prop = path.pop();
         return hasProp(result, prop) ? result[prop] : defaults;
       },
-      writable: false,
-      configurable: false,
+      writable: true,
+      configurable: true,
       enumerable: false
     }), _defineProperty(_Object$definePropert, "set", {
       value: function value(name, _value2) {
@@ -770,13 +800,15 @@ function EJS(options) {
   var compiler = new Compiler(config);
   var cache = new Cache();
   var template = new Template(config, cache, compiler);
-  var output = function output(path, context) {
-    var params = [context, context.getComponent(), context.getBuffer(), safeValue];
-    config.globalHelpers.forEach(function (name) {
-      if (isFunction(context[name])) params.push(context[name].bind(context));
-    });
+  var output = function output(path, scope) {
+    var globalHelpers = config.globalHelpers;
+    var params = [scope, scope.getComponent(), scope.getBuffer(), safeValue].concat(globalHelpers.filter(function (name) {
+      return isFunction(scope[name]);
+    }).map(function (name) {
+      return scope[name].bind(scope);
+    }));
     return template.get(path).then(function (callback) {
-      return callback.apply(context, params);
+      return callback.apply(scope, params);
     });
   };
   var require = function require(name) {
@@ -837,7 +869,7 @@ var httpRequest = function httpRequest(path, template) {
   return fetch(joinPath(path, template)).then(function (response) {
     return response.text();
   }, function (reason) {
-    return String(reason);
+    return new TemplateError(reason);
   });
 };
 

package/dist/cjs/bundler.js

@@ -0,0 +1,171 @@
+'use strict';
+
+var fs = require('fs');
+var glob = require('glob');
+var path = require('path');
+var terser = require('terser');
+var index_js = require('./index.js');
+var babel = require('@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 = index_js.configure(config || {});
+        this.templates = {};
+    }
+    stageRead(path$1) {
+        return fs.promises
+            .readFile(path.join(this.config.path, path$1))
+            .then((response) => response.toString())
+    }
+    stageCompile(content, name) {
+        return index_js.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 terser.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 = fs.promises.watch(this.config.path, { recursive: true });
+            for await (const { filename } of watcher) {
+                if (path.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.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 = path.dirname(file);
+            const folderExists = await fs.promises
+                .stat(folderPath)
+                .then(() => true)
+                .catch(() => false);
+            if (folderExists === false) {
+                await fs.promises.mkdir(folderPath, { recursive: true });
+            }
+            await fs.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();
+        },
+    }
+};
+
+exports.Bundler = Bundler;
+exports.ejsBundle = ejsBundle;

package/dist/cjs/index.js

@@ -326,7 +326,7 @@ function Compiler(config) {
       });
     });
     source += "');";
-    source = "try{".concat(source, "}catch(e){console.info(e)}");
+    source = "try{".concat(source, "}catch(e){return ").concat(BUFFER, ".error(e)}");
     if (compiler.withObject) {
       source = "with(".concat(SCOPE, "){").concat(source, "}");
     }
@@ -438,11 +438,36 @@ var element = function 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(function (list) {
     return list.join('');
   });
 }
+function reject(error) {
+  return Promise.reject(new TemplateSyntaxError(error.message));
+}
 function createBuffer() {
   var store = [],
     array = [];
@@ -462,7 +487,7 @@ function createBuffer() {
     return resolve(result);
   };
   buffer.error = function (e) {
-    throw e;
+    return reject(e);
   };
   buffer.end = function () {
     return resolve(array);
@@ -487,6 +512,11 @@ function Context(config) {
     this.helpers = function (methods) {
       extend(Scope.prototype, methods || {});
     };
+    /**
+     * @name ContextScope
+     * @param data
+     * @constructor
+     */
     function Scope(data) {
       this[BLOCKS] = {};
       this[MACRO] = {};
@@ -632,8 +662,8 @@ function Context(config) {
         var prop = path.pop();
         return hasProp(result, prop) ? result[prop] : defaults;
       },
-      writable: false,
-      configurable: false,
+      writable: true,
+      configurable: true,
       enumerable: false
     }), _defineProperty(_Object$definePropert, "set", {
       value: function value(name, _value2) {
@@ -773,13 +803,15 @@ function EJS(options) {
   var compiler = new Compiler(config);
   var cache = new Cache();
   var template = new Template(config, cache, compiler);
-  var output = function output(path, context) {
-    var params = [context, context.getComponent(), context.getBuffer(), safeValue];
-    config.globalHelpers.forEach(function (name) {
-      if (isFunction(context[name])) params.push(context[name].bind(context));
-    });
+  var output = function output(path, scope) {
+    var globalHelpers = config.globalHelpers;
+    var params = [scope, scope.getComponent(), scope.getBuffer(), safeValue].concat(globalHelpers.filter(function (name) {
+      return isFunction(scope[name]);
+    }).map(function (name) {
+      return scope[name].bind(scope);
+    }));
     return template.get(path).then(function (callback) {
-      return callback.apply(context, params);
+      return callback.apply(scope, params);
     });
   };
   var require = function require(name) {
@@ -840,7 +872,7 @@ function readFile(path, template) {
   return new Promise(function (resolve, reject) {
     fs.readFile(joinPath(path, template), function (error, data) {
       if (error) {
-        reject(error);
+        reject(new TemplateError(error));
       } else {
         resolve(data.toString());
       }

package/dist/cjs/worker.js

@@ -678,7 +678,7 @@ function Compiler(config) {
       });
     });
     source += "');";
-    source = "try{".concat(source, "}catch(e){console.info(e)}");
+    source = "try{".concat(source, "}catch(e){return ").concat(BUFFER, ".error(e)}");
     if (compiler.withObject) {
       source = "with(".concat(SCOPE, "){").concat(source, "}");
     }
@@ -761,11 +761,36 @@ var element = function 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(function (list) {
     return list.join('');
   });
 }
+function reject(error) {
+  return Promise.reject(new TemplateSyntaxError(error.message));
+}
 function createBuffer() {
   var store = [],
     array = [];
@@ -785,7 +810,7 @@ function createBuffer() {
     return resolve(result);
   };
   buffer.error = function (e) {
-    throw e;
+    return reject(e);
   };
   buffer.end = function () {
     return resolve(array);
@@ -810,6 +835,11 @@ function Context(config) {
     this.helpers = function (methods) {
       extend(Scope.prototype, methods || {});
     };
+    /**
+     * @name ContextScope
+     * @param data
+     * @constructor
+     */
     function Scope(data) {
       this[BLOCKS] = {};
       this[MACRO] = {};
@@ -955,8 +985,8 @@ function Context(config) {
         var prop = path.pop();
         return hasProp(result, prop) ? result[prop] : defaults;
       },
-      writable: false,
-      configurable: false,
+      writable: true,
+      configurable: true,
       enumerable: false
     }), _defineProperty(_Object$definePropert, "set", {
       value: function value(name, _value2) {
@@ -1096,13 +1126,15 @@ function EJS(options) {
   var compiler = new Compiler(config);
   var cache = new Cache();
   var template = new Template(config, cache, compiler);
-  var output = function output(path, context) {
-    var params = [context, context.getComponent(), context.getBuffer(), safeValue];
-    config.globalHelpers.forEach(function (name) {
-      if (isFunction(context[name])) params.push(context[name].bind(context));
-    });
+  var output = function output(path, scope) {
+    var globalHelpers = config.globalHelpers;
+    var params = [scope, scope.getComponent(), scope.getBuffer(), safeValue].concat(globalHelpers.filter(function (name) {
+      return isFunction(scope[name]);
+    }).map(function (name) {
+      return scope[name].bind(scope);
+    }));
     return template.get(path).then(function (callback) {
-      return callback.apply(context, params);
+      return callback.apply(scope, params);
     });
   };
   var require = function require(name) {
@@ -1159,33 +1191,73 @@ function EJS(options) {
   return this;
 }
 
-var templates = {};
+var templateCache = {};
 var ejs = new EJS({
   cache: false,
   withObject: false,
   resolver: function resolver(path, name) {
-    if (name in templates) {
-      return Promise.resolve(templates[name]);
-    }
-    return Promise.resolve(['template not found', name]);
+    return new Promise(function (resolve, reject) {
+      if (templateCache.hasOwnProperty(name)) {
+        resolve(templateCache[name]);
+      } else {
+        reject(new TemplateNotFound("template ".concat(name, " not found")));
+      }
+    });
   }
 });
-function useTemplates(_x) {
-  return _useTemplates.apply(this, arguments);
+var getOrigin = function getOrigin(url, secure) {
+  url = new URL(url);
+  if (secure) url.protocol = 'https:';
+  return url.origin;
+};
+function setTemplates(list) {
+  Object.assign(templateCache, list || {});
 }
-function _useTemplates() {
-  _useTemplates = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(list) {
-    return _regeneratorRuntime().wrap(function _callee$(_context) {
-      while (1) switch (_context.prev = _context.next) {
-        case 0:
-          Object.assign(templates, list || {});
-        case 1:
-        case "end":
-          return _context.stop();
-      }
-    }, _callee);
-  }));
-  return _useTemplates.apply(this, arguments);
+
+/**
+ * @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(_ref) {
+  var _ref$secure = _ref.secure,
+    secure = _ref$secure === void 0 ? true : _ref$secure,
+    _ref$version = _ref.version,
+    version = _ref$version === void 0 ? '1.0' : _ref$version;
+  return /*#__PURE__*/function () {
+    var _ref2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(c, next) {
+      return _regeneratorRuntime().wrap(function _callee$(_context) {
+        while (1) switch (_context.prev = _context.next) {
+          case 0:
+            c.data = context({});
+            c.data.set('version', version);
+            c.data.set('origin', getOrigin(c.req.url, secure));
+            c.ejs = function (name, data) {
+              return render(name, Object.assign({}, c.data, data));
+            };
+            c.render = function (name, data) {
+              return c.html(c.ejs(name, data));
+            };
+            _context.next = 7;
+            return next();
+          case 7:
+          case "end":
+            return _context.stop();
+        }
+      }, _callee);
+    }));
+    return function (_x, _x2) {
+      return _ref2.apply(this, arguments);
+    };
+  }();
 }
 var render = ejs.render,
   context = ejs.context,
@@ -1202,4 +1274,5 @@ exports.create = create;
 exports.helpers = helpers;
 exports.preload = preload;
 exports.render = render;
-exports.useTemplates = useTemplates;
+exports.setRenderer = setRenderer;
+exports.setTemplates = setTemplates;