@kosatyi/ejs 0.0.1-alpha.1

package/dist/ejs.cjs

@@ -0,0 +1,961 @@
+'use strict';
+
+var path = require('path');
+var fs = require('fs');
+var chokidar = require('chokidar');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var path__default = /*#__PURE__*/_interopDefaultLegacy(path);
+var fs__default = /*#__PURE__*/_interopDefaultLegacy(fs);
+var chokidar__default = /*#__PURE__*/_interopDefaultLegacy(chokidar);
+
+var defaults = {};
+defaults["export"] = 'ejs.precompiled';
+defaults.path = 'views';
+defaults.resolver = null;
+defaults.extension = {
+  template: 'ejs',
+  module: 'mjs'
+};
+defaults.vars = {
+  EXTEND: '$$$',
+  BUFFER: '$$a',
+  OUTPUT: '$$i',
+  LAYOUT: '$$l',
+  MACROS: '$$m',
+  PRINT: '$$j',
+  BLOCKS: '$$b',
+  ERROR: '$$e',
+  SCOPE: '$$s',
+  SAFE: '$$v'
+};
+defaults.token = {
+  start: '<%',
+  end: '%>',
+  regex: '([\\s\\S]+?)'
+};
+
+var typeProp = function typeProp() {
+  var args = [].slice.call(arguments);
+  var callback = args.shift();
+  return args.filter(callback).pop();
+};
+var isFunction = function isFunction(v) {
+  return typeof v === 'function';
+};
+var isString = function isString(v) {
+  return typeof v === 'string';
+};
+
+var isNode = new Function('try {return this===global;}catch(e){return false;}');
+var symbolEntities = {
+  "'": "'",
+  '\\': '\\',
+  '\r': 'r',
+  '\n': 'n',
+  '\t': 't',
+  "\u2028": 'u2028',
+  "\u2029": 'u2029'
+};
+var htmlEntities = {
+  '&': '&amp;',
+  '<': '&lt;',
+  '>': '&gt;',
+  '"': '&quot;',
+  "'": '&#x27;'
+};
+
+var regexKeys = function regexKeys(obj) {
+  return new RegExp(['[', Object.keys(obj).join(''), ']'].join(''), 'g');
+};
+
+var htmlEntitiesMatch = regexKeys(htmlEntities);
+var symbolEntitiesMatch = regexKeys(symbolEntities);
+var entities = function entities() {
+  var string = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';
+  return ('' + string).replace(htmlEntitiesMatch, function (match) {
+    return htmlEntities[match];
+  });
+};
+var symbols = function symbols(string) {
+  return ('' + string).replace(symbolEntitiesMatch, function (match) {
+    return '\\' + symbolEntities[match];
+  });
+};
+var safeValue = function safeValue(value, escape, check) {
+  return (check = value) == null ? '' : escape ? entities(check) : check;
+};
+var getPath = function getPath(context, name) {
+  var data = context;
+  var chunk = name.split('.');
+  var prop = chunk.pop();
+  chunk.forEach(function (part) {
+    data = data[part] = data[part] || {};
+  });
+  return [data, prop];
+};
+var extend = function extend() {
+  for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+    args[_key] = arguments[_key];
+  }
+
+  var target = args.shift();
+  return args.filter(function (source) {
+    return source;
+  }).reduce(function (target, source) {
+    return Object.assign(target, source);
+  }, target);
+};
+var noop = function noop() {};
+var each = function each(object, callback) {
+  var prop;
+
+  for (prop in object) {
+    if (hasProp(object, prop)) {
+      callback(object[prop], prop, object);
+    }
+  }
+};
+var map = function map(object, callback, context) {
+  var result = [];
+  each(object, function (value, key, object) {
+    var item = callback(value, key, object);
+
+    if (item !== undefined) {
+      result.push(item);
+    }
+  });
+  return result;
+};
+var filter = function filter(object, callback, context) {
+  var isArray = object instanceof Array;
+  var result = isArray ? [] : {};
+  each(object, function (value, key, object) {
+    var item = callback(value, key, object);
+
+    if (item !== undefined) {
+      if (isArray) {
+        result.push(item);
+      } else {
+        result[key] = item;
+      }
+    }
+  });
+  return result;
+};
+var omit = function omit(object, list) {
+  return filter(object, function (value, key) {
+    if (list.indexOf(key) === -1) {
+      return value;
+    }
+  });
+};
+var hasProp = function hasProp(object, prop) {
+  return object && object.hasOwnProperty(prop);
+};
+
+var selfClosed = ['area', 'base', 'br', 'col', 'embed', 'hr', 'img', 'input', 'link', 'meta', 'param', 'source', 'track', 'wbr'];
+var space = ' ';
+var quote = '"';
+var equal = '=';
+var slash = '/';
+var lt = '<';
+var gt = '>';
+function element(tag, attrs, content) {
+  var result = [];
+  var hasClosedTag = selfClosed.indexOf(tag) === -1;
+  var attributes = map(attrs, function (value, key) {
+    if (value !== null && value !== undefined) {
+      return [entities(key), [quote, entities(value), quote].join('')].join(equal);
+    }
+  }).join(space);
+  result.push([lt, tag, space, attributes, gt].join(''));
+
+  if (content) {
+    result.push(content instanceof Array ? content.join('') : content);
+  }
+
+  if (hasClosedTag) {
+    result.push([lt, slash, tag, gt].join(''));
+  }
+
+  return result.join('');
+}
+
+var tags = [{
+  symbol: '-',
+  format: function format(value) {
+    return "'+\n".concat(this.SAFE, "(").concat(value, ",1)+\n'");
+  }
+}, {
+  symbol: '=',
+  format: function format(value) {
+    return "'+\n".concat(this.SAFE, "(").concat(value, ")+\n'");
+  }
+}, {
+  symbol: '#',
+  format: function format(value) {
+    return "'+\n/**".concat(value, "**/+\n'");
+  }
+}, {
+  symbol: '',
+  format: function format(value) {
+    return "')\n".concat(value, "\n").concat(this.BUFFER, "('");
+  }
+}];
+
+var match = function match(regex, text, callback) {
+  var index = 0;
+  text.replace(regex, function () {
+    var params = [].slice.call(arguments, 0, -1);
+    var offset = params.pop();
+    var match = params.shift();
+    callback(params, index, offset);
+    index = offset + match.length;
+    return match;
+  });
+};
+/**
+ *
+ * @param {Object} config
+ * @return {function(*, *): Function}
+ * @constructor
+ */
+
+
+var Compiler = function Compiler(config) {
+  var token = config.token;
+  var vars = config.vars;
+  var module = config.extension.module;
+  var matches = [];
+  var formats = [];
+  var slurp = {
+    match: '[ \\t]*',
+    start: [token.start, '_'],
+    end: ['_', token.end]
+  };
+  tags.forEach(function (item) {
+    matches.push(token.start.concat(item.symbol).concat(token.regex).concat(token.end));
+    formats.push(item.format.bind(vars));
+  });
+  var regex = new RegExp(matches.join('|').concat('|$'), 'g');
+  var slurpStart = new RegExp([slurp.match, slurp.start].join(''), 'gm');
+  var slurpEnd = new RegExp([slurp.end, slurp.match].join(''), 'gm');
+  /**
+   * @type Function
+   * @name Compile
+   */
+
+  return function (content, path) {
+    var SCOPE = vars.SCOPE,
+        SAFE = vars.SAFE,
+        BUFFER = vars.BUFFER;
+    var extension = path.split('.').pop();
+    content = content.replace(/[\r\n]+/g, '\n').replace(/^\s+|\s+$/gm, '');
+    content = content.replace(slurpStart, slurp.start).replace(slurpEnd, slurp.end);
+
+    if (extension === module) {
+      content = [token.start, content, token.end].join('\n');
+    }
+
+    var source = "".concat(BUFFER, "('");
+    match(regex, content, function (params, index, offset) {
+      source += symbols(content.slice(index, offset));
+      params.forEach(function (value, index) {
+        if (value) source += formats[index](value);
+      });
+    });
+    source += "');";
+    source = "with(".concat(SCOPE, "){").concat(source, "}");
+    source = "".concat(BUFFER, ".start();").concat(source, "return ").concat(BUFFER, ".end();");
+    source += "\n//# sourceURL=".concat(path);
+    var result = null;
+
+    try {
+      result = new Function(SCOPE, BUFFER, SAFE, source);
+      result.source = "(function(".concat(SCOPE, ",").concat(BUFFER, ",").concat(SAFE, "){\n").concat(source, "\n})"); //result.source = result.toString()
+    } catch (e) {
+      e.filename = path;
+      e.source = source;
+      throw e;
+    }
+
+    return result;
+  };
+};
+
+var Wrapper = function Wrapper(config) {
+  var name = config["export"];
+  return function (list) {
+    var out = '(function(o){\n';
+    list.forEach(function (item) {
+      out += 'o[' + JSON.stringify(item.name) + ']=' + String(item.content) + '\n';
+    });
+    out += '})(window["' + name + '"] = window["' + name + '"] || {});\n';
+    return out;
+  };
+};
+
+var HttpRequest = function HttpRequest(template) {
+  return window.fetch(template).then(function (response) {
+    return response.text();
+  });
+};
+
+var FileSystem = function FileSystem(template) {
+  return new Promise(function (resolve, reject) {
+    fs__default["default"].readFile(template, function (error, data) {
+      if (error) {
+        reject(error);
+      } else {
+        resolve(data.toString());
+      }
+    });
+  });
+};
+
+var Watcher = function Watcher(path, cache) {
+  return chokidar__default["default"].watch('.', {
+    cwd: path
+  }).on('change', function (name) {
+    cache.remove(name);
+  }).on('error', function (error) {
+    console.log('watcher error: ' + error);
+  });
+};
+
+var Template = function Template(config, cache, compile) {
+  var path = config.path;
+  config.token || {};
+  var resolver = isFunction(config.resolver) ? config.resolver : isNode() ? FileSystem : HttpRequest;
+
+  var normalize = function normalize(template) {
+    template = [path, template].join('/');
+    template = template.replace(/\/\//g, '/');
+    return template;
+  };
+
+  var resolve = function resolve(template) {
+    return resolver(normalize(template));
+  };
+
+  var result = function result(content, template) {
+    cache.set(template, content);
+    return content;
+  };
+
+  var get = function get(template) {
+    if (cache.exist(template)) {
+      return cache.resolve(template);
+    }
+
+    var content = resolve(template).then(function (content) {
+      return result(compile(content, template), template);
+    });
+    return result(content, template);
+  };
+
+  if (config.watch && isNode()) {
+    Watcher(path, cache);
+  }
+
+  return get;
+};
+
+function _defineProperty(obj, key, value) {
+  if (key in obj) {
+    Object.defineProperty(obj, key, {
+      value: value,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  } else {
+    obj[key] = value;
+  }
+
+  return obj;
+}
+
+var resolve = function resolve(list) {
+  return Promise.all(list).then(function (list) {
+    return list.join('');
+  });
+};
+/**
+ *
+ * @return {function}
+ */
+
+
+var Buffer = function Buffer() {
+  var store = [],
+      array = [];
+
+  function buffer(value) {
+    array.push(value);
+  }
+
+  buffer.start = function () {
+    array = [];
+  };
+
+  buffer.backup = function () {
+    store.push(array.concat());
+    array = [];
+  };
+
+  buffer.restore = function () {
+    var result = array.concat();
+    array = store.pop();
+    return resolve(result);
+  };
+
+  buffer.end = function () {
+    return resolve(array);
+  };
+
+  return buffer;
+};
+
+/**
+ *
+ * @param {{}} instance
+ * @method create
+ */
+
+var Component = function Component(instance) {
+  var defaults = extend({}, instance.props);
+  var create = instance.create;
+  return {
+    element: element,
+    create: create,
+    render: function render(props) {
+      return this.create(extend({}, defaults, props));
+    }
+  };
+};
+
+var Scope = function Scope(config, methods) {
+  var _Object$definePropert;
+
+  /**
+   *
+   */
+  var _config$vars = config.vars,
+      EXTEND = _config$vars.EXTEND,
+      MACROS = _config$vars.MACROS,
+      LAYOUT = _config$vars.LAYOUT,
+      BLOCKS = _config$vars.BLOCKS,
+      BUFFER = _config$vars.BUFFER;
+  /**
+   *
+   * @param data
+   * @constructor
+   */
+
+  function Scope() {
+    var data = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    extend(this, data);
+  }
+  /**
+   *
+   */
+
+
+  Object.defineProperties(Scope.prototype, (_Object$definePropert = {}, _defineProperty(_Object$definePropert, BUFFER, {
+    value: Buffer(),
+    writable: false,
+    configurable: false,
+    enumerable: false
+  }), _defineProperty(_Object$definePropert, BLOCKS, {
+    value: {},
+    writable: false,
+    configurable: false,
+    enumerable: false
+  }), _defineProperty(_Object$definePropert, EXTEND, {
+    value: false,
+    writable: true,
+    configurable: false,
+    enumerable: false
+  }), _defineProperty(_Object$definePropert, LAYOUT, {
+    value: false,
+    writable: true,
+    configurable: false,
+    enumerable: false
+  }), _defineProperty(_Object$definePropert, "setBuffer", {
+    value: function value(_value) {
+      this[BUFFER] = _value;
+    },
+    writable: false,
+    configurable: false
+  }), _defineProperty(_Object$definePropert, "getBuffer", {
+    value: function value() {
+      return this[BUFFER];
+    },
+    writable: false,
+    configurable: false
+  }), _defineProperty(_Object$definePropert, "setBlocks", {
+    value: function value(_value2) {
+      this[BLOCKS] = _value2;
+    },
+    writable: false,
+    configurable: false
+  }), _defineProperty(_Object$definePropert, "getBlocks", {
+    value: function value() {
+      return this[BLOCKS];
+    },
+    writable: false,
+    configurable: false
+  }), _defineProperty(_Object$definePropert, "setExtend", {
+    value: function value(_value3) {
+      this[EXTEND] = _value3;
+    },
+    writable: false,
+    configurable: false
+  }), _defineProperty(_Object$definePropert, "getExtend", {
+    value: function value() {
+      return this[EXTEND];
+    },
+    writable: false,
+    configurable: false
+  }), _defineProperty(_Object$definePropert, "setLayout", {
+    value: function value(layout) {
+      this[LAYOUT] = layout;
+    },
+    writable: false,
+    configurable: false
+  }), _defineProperty(_Object$definePropert, "getLayout", {
+    value: function value() {
+      return this[LAYOUT];
+    },
+    writable: false,
+    configurable: false
+  }), _Object$definePropert));
+
+  Scope.helpers = function (methods) {
+    extend(Scope.prototype, methods);
+  };
+  /**
+   * @lends Scope.prototype
+   */
+
+
+  Scope.helpers(methods);
+  /**
+   * @lends Scope.prototype
+   */
+
+  Scope.helpers({
+    /**
+     * @return {*}
+     */
+    clone: function clone(exclude_blocks) {
+      var filter = [LAYOUT, EXTEND, MACROS, BUFFER];
+
+      if (exclude_blocks === true) {
+        filter.push(BLOCKS);
+      }
+
+      return omit(this, filter);
+    },
+
+    /**
+     * Join values to output buffer
+     * @memberOf global
+     * @type Function
+     */
+    echo: function echo() {
+      var buffer = this.getBuffer();
+      var params = [].slice.call(arguments);
+      params.forEach(function (item) {
+        buffer(item);
+      });
+    },
+
+    /**
+     * Buffered output callback
+     * @type Function
+     * @param {Function} callback
+     * @param {Boolean} [echo]
+     * @return {Function}
+     */
+    macro: function macro(callback, echo) {
+      var buffer = this.getBuffer();
+
+      var macro = function () {
+        buffer.backup();
+
+        if (isFunction(callback)) {
+          callback.apply(this, arguments);
+        }
+
+        var result = buffer.restore();
+        return echo === true ? this.echo(result) : result;
+      }.bind(this);
+
+      macro.ctx = this;
+      return macro;
+    },
+
+    /**
+     * @memberOf global
+     * @param value
+     * @param callback
+     * @return {Promise<unknown>}
+     */
+    resolve: function resolve(value, callback) {
+      return Promise.resolve(value).then(callback.bind(this));
+    },
+
+    /**
+     * @memberOf global
+     */
+    async: function async(promise, callback) {
+      var _this = this;
+
+      this.echo(this.resolve(promise, function (data) {
+        return _this.macro(callback)(data);
+      }));
+    },
+
+    /**
+     * @memberOf global
+     */
+    node: element,
+
+    /**
+     * @memberOf global
+     */
+    element: function element$1(tag, attr, content) {
+      if (isFunction(content)) {
+        content = this.macro(content)();
+      }
+
+      this.echo(this.resolve(content, function (content) {
+        return element(tag, attr, content);
+      }));
+    },
+
+    /**
+     * @memberOf global
+     * @param {String} namespace
+     * @param {Object} instance
+     */
+    component: function component(namespace, instance) {
+      instance = Component(instance);
+      this.set(namespace, function (props) {
+        this.echo(instance.render(props));
+      }.bind(this));
+    },
+
+    /**
+     * @memberOf global
+     * @param name
+     * @param defaults
+     */
+    get: function get(name, defaults) {
+      var path = getPath(this, name);
+      var result = path.shift();
+      var prop = path.pop();
+      return hasProp(result, prop) ? result[prop] : defaults;
+    },
+
+    /**
+     * @memberOf global
+     * @param {String} name
+     * @param value
+     * @return
+     */
+    set: function set(name, value) {
+      var path = getPath(this, name);
+      var result = path.shift();
+      var prop = path.pop();
+
+      if (this.getExtend()) {
+        if (hasProp(result, prop)) {
+          return result[prop];
+        }
+      }
+
+      result[prop] = value;
+    },
+
+    /**
+     * @memberOf global
+     * @param name
+     */
+    call: function call(name) {
+      var params = [].slice.call(arguments, 1);
+      var path = getPath(this, name);
+      var result = path.shift();
+      var prop = path.pop();
+
+      if (isFunction(result[prop])) {
+        return result[prop].apply(result, params);
+      }
+    },
+
+    /**
+     * @memberOf global
+     * @param object
+     * @param callback
+     */
+    each: function each$1(object, callback) {
+      if (isString(object)) {
+        object = this.get(object, []);
+      }
+
+      each(object, callback);
+    },
+
+    /**
+     * @memberOf global
+     * @param {String} layout
+     */
+    extend: function extend(layout) {
+      this.setExtend(true);
+      this.setLayout(layout);
+    },
+
+    /**
+     * @memberOf global
+     * @param name
+     * @param callback
+     * @return {*}
+     */
+    block: function block(name, callback) {
+      var blocks = this.getBlocks();
+      var macro = this.macro(callback);
+
+      if (this.getExtend()) {
+        blocks[name] = macro;
+      } else {
+        var block = blocks[name];
+
+        if (block) {
+          var parent = function () {
+            this.echo(macro());
+          }.bind(block.ctx);
+
+          this.echo(block(parent));
+        } else {
+          this.echo(macro(noop));
+        }
+      }
+    },
+
+    /**
+     * @memberOf global
+     * @param {string} path
+     * @param {object} [data]
+     * @param {boolean} [cx]
+     */
+    include: function include(path, data, cx) {
+      var context = cx === false ? {} : this.clone(true);
+      var params = extend(context, data || {});
+      var promise = this.render(path, params);
+      this.echo(promise);
+    },
+
+    /**
+     * @memberOf global
+     * @param {string} path
+     */
+    use: function use(path) {
+      var scope = this;
+
+      var promise = this.require(path);
+
+      this.echo(promise);
+      return {
+        as: function as(namespace) {
+          promise.then(function (exports) {
+            scope.set(namespace, exports);
+          });
+          return this;
+        }
+      };
+    },
+
+    /**
+     * @memberOf global
+     * @param {string} path
+     */
+    from: function from(path) {
+      var scope = this;
+
+      var promise = this.require(path);
+
+      this.echo(promise);
+      return {
+        use: function use() {
+          var params = [].slice.call(arguments);
+          promise.then(function (exports) {
+            params.forEach(function (name) {
+              scope.set(name, exports[name]);
+            });
+          });
+          return this;
+        }
+      };
+    }
+  });
+  return Scope;
+};
+
+function Cache(config) {
+  var namespace = config["export"];
+  var list = {};
+  var cache = {
+    preload: function preload() {
+      if (isNode() === false) {
+        this.load(window[namespace]);
+      }
+
+      return this;
+    },
+    exist: function exist(key) {
+      return hasProp(list, key);
+    },
+    get: function get(key) {
+      return list[key];
+    },
+    remove: function remove(key) {
+      delete list[key];
+    },
+    resolve: function resolve(key) {
+      return Promise.resolve(this.get(key));
+    },
+    set: function set(key, value) {
+      list[key] = value;
+      return this;
+    },
+    load: function load(data) {
+      extend(list, data);
+      return this;
+    }
+  };
+  return cache.preload();
+}
+
+function init(options) {
+  /**
+   * @type {Object}
+   */
+  var config = {};
+  var _helpers = {};
+
+  var ext = function ext(path, defaults) {
+    var ext = path.split('.').pop();
+
+    if (ext !== defaults) {
+      path = [path, defaults].join('.');
+    }
+
+    return path;
+  };
+
+  var view = {
+    element: element,
+    output: function output(path, scope) {
+      return view.template(path).then(function (template) {
+        return template.call(scope, scope, scope.getBuffer(), safeValue);
+      });
+    },
+    render: function render(name, data) {
+      var filepath = ext(name, config.extension.template);
+      var scope = new view.scope(data);
+      return view.output(filepath, scope).then(function (content) {
+        if (scope.getExtend()) {
+          scope.setExtend(false);
+          var layout = scope.getLayout();
+
+          var _data = scope.clone();
+
+          return view.render(layout, _data);
+        }
+
+        return content;
+      });
+    },
+    require: function require(name) {
+      var filepath = ext(name, config.extension.module);
+      var scope = new view.scope({});
+      return view.output(filepath, scope).then(function () {
+        return scope.clone(true);
+      });
+    },
+    helpers: function helpers(methods) {
+      methods = methods || {};
+      extend(_helpers, methods);
+      view.scope.helpers(methods);
+    },
+    configure: function configure(options) {
+      config["export"] = typeProp(isString, defaults["export"], options["export"]);
+      config.path = typeProp(isString, defaults.path, options.path);
+      config.resolver = typeProp(isFunction, defaults.resolver, options.resolver);
+      config.extension = extend({}, defaults.extension, options.extension);
+      config.token = extend({}, defaults.token, options.token);
+      config.vars = extend({}, defaults.vars, options.vars);
+      view.scope = Scope(config, _helpers);
+      view.compile = Compiler(config);
+      view.wrapper = Wrapper(config);
+      view.cache = Cache(config);
+      view.template = Template(config, view.cache, view.compile);
+      return view;
+    }
+  };
+  /**
+   *
+   * @param name
+   * @param options
+   * @param callback
+   * @return {*}
+   * @private
+   */
+
+  view.__express = function (name, options, callback) {
+    if (isFunction(options)) {
+      callback = options;
+      options = {};
+    }
+
+    options = options || {};
+    var settings = options.settings || {};
+    var viewPath = settings['views'];
+    var viewOptions = settings['view options'] || {};
+    var filename = path__default["default"].relative(viewPath, name);
+    viewOptions.path = viewPath;
+    view.configure(viewOptions);
+    return view.render(filename, options).then(function (content) {
+      callback(null, content);
+    })["catch"](function (error) {
+      callback(error);
+    });
+  };
+  /**
+   *
+   */
+
+
+  view.configure(options || {});
+  /**
+   *
+   */
+
+  view.helpers({
+    require: function require(name) {
+      return view.require(name, this);
+    },
+    render: function render(name, data) {
+      return view.render(name, data);
+    }
+  });
+  return view;
+}
+
+var index = init();
+
+module.exports = index;