@kosatyi/ejs 0.0.1-alpha.1

package/dist/ejs.mjs

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