@kosatyi/ejs 0.0.76 → 0.0.77

package/dist/esm/worker.js

@@ -0,0 +1,966 @@
+const typeProp = function () {
+    const args = [].slice.call(arguments);
+    const callback = args.shift();
+    return args.filter(callback).pop()
+};
+const isArray = (v) => Array.isArray(v);
+const isFunction = (v) => typeof v === 'function';
+const isString = (v) => typeof v === 'string';
+const isBoolean = (v) => typeof v === 'boolean';
+const isUndefined = (v) => typeof v === 'undefined';
+
+const isNodeEnv =
+    Object.prototype.toString.call(
+        typeof process !== 'undefined' ? process : 0
+    ) === '[object process]';
+
+const isNode = () => isNodeEnv;
+
+const symbolEntities = {
+    "'": "'",
+    '\\': '\\',
+    '\r': 'r',
+    '\n': 'n',
+    '\t': 't',
+    '\u2028': 'u2028',
+    '\u2029': 'u2029',
+};
+
+const htmlEntities = {
+    '&': '&',
+    '<': '&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) => {
+    const check = value;
+    return check == null ? '' : escape === true ? entities(check) : check
+};
+
+const instanceOf = (object, instance) => {
+    return Boolean(object instanceof instance)
+};
+
+const getPath = (context, name, strict) => {
+    let data = context;
+    let chunks = String(name).split('.');
+    let prop = chunks.pop();
+    for (let i = 0; i < chunks.length; i++) {
+        const part = chunks[i];
+        if (isFunction(data['toJSON'])) {
+            data = data.toJSON();
+        }
+        if (strict && data.hasOwnProperty(part) === false) {
+            data = {};
+            break
+        }
+        data = data[part] = data[part] || {};
+    }
+    if (isFunction(data['toJSON'])) {
+        data = data.toJSON();
+    }
+    return [data, prop]
+};
+
+const ext = (path, defaults) => {
+    const ext = path.split('.').pop();
+    if (ext !== defaults) {
+        path = [path, defaults].join('.');
+    }
+    return path
+};
+
+/**
+ * @type {<T extends {}, U, V, W,Y>(T,U,V,W,Y)=> T & U & V & W & Y}
+ */
+const extend = (target, ...args) => {
+    return args
+        .filter((source) => source)
+        .reduce((target, source) => 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 (isUndefined(item) === false) {
+                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 (isUndefined(item) === false) {
+                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 resolve$1 = (value, callback, context) =>
+    Promise.resolve(value).then(callback.bind(context));
+
+const hasProp = (object, prop) => {
+    return object && object.hasOwnProperty(prop)
+};
+
+const defaults = {};
+
+defaults.export = 'ejsPrecompiled';
+defaults.cache = true;
+defaults.chokidar = null;
+defaults.path = 'views';
+defaults.resolver = function (path, template) {
+    return Promise.resolve(
+        ['resolver is not defined', path, template].join(' ')
+    )
+};
+defaults.extension = 'ejs';
+defaults.rmWhitespace = true;
+defaults.withObject = true;
+defaults.globalHelpers = [];
+defaults.vars = {
+    SCOPE: 'ejs',
+    COMPONENT: 'ui',
+    EXTEND: '$$e',
+    BUFFER: '$$a',
+    LAYOUT: '$$l',
+    BLOCKS: '$$b',
+    MACRO: '$$m',
+    SAFE: '$$v',
+};
+defaults.token = {
+    start: '<%',
+    end: '%>',
+    regex: '([\\s\\S]+?)',
+};
+
+const configSchema = (config, options) => {
+    extend(config, {
+        path: typeProp(isString, defaults.path, config.path, options.path),
+        export: typeProp(
+            isString,
+            defaults.export,
+            config.export,
+            options.export
+        ),
+        resolver: typeProp(
+            isFunction,
+            defaults.resolver,
+            config.resolver,
+            options.resolver
+        ),
+        extension: typeProp(
+            isString,
+            defaults.extension,
+            config.extension,
+            options.extension
+        ),
+        withObject: typeProp(
+            isBoolean,
+            defaults.withObject,
+            config.withObject,
+            options.withObject
+        ),
+        rmWhitespace: typeProp(
+            isBoolean,
+            defaults.rmWhitespace,
+            config.rmWhitespace,
+            options.rmWhitespace
+        ),
+        cache: typeProp(isBoolean, defaults.cache, config.cache, options.cache),
+        token: extend({}, defaults.token, config.token, options.token),
+        vars: extend({}, defaults.vars, config.vars, options.vars),
+        globalHelpers: typeProp(
+            isArray,
+            defaults.globalHelpers,
+            config.globalHelpers,
+            options.globalHelpers
+        ),
+    });
+};
+
+const global = typeof globalThis !== 'undefined' ? globalThis : window || self;
+
+function Cache(config) {
+    if (instanceOf(this, Cache) === false) return new Cache()
+    const cache = {
+        enabled: true,
+        list: {},
+    };
+    this.configure = function (config) {
+        cache.enabled = config.cache;
+        if (isNode() === false) {
+            this.load(global[config.export]);
+        }
+    };
+    this.clear = function () {
+        cache.list = {};
+    };
+    this.load = function (data) {
+        if (cache.enabled) {
+            extend(cache.list, data || {});
+        }
+        return this
+    };
+    this.get = function (key) {
+        if (cache.enabled) {
+            return cache.list[key]
+        }
+    };
+    this.set = function (key, value) {
+        if (cache.enabled) {
+            cache.list[key] = value;
+        }
+        return this
+    };
+    this.resolve = function (key) {
+        return Promise.resolve(this.get(key))
+    };
+    this.remove = function (key) {
+        delete cache.list[key];
+    };
+    this.exist = function (key) {
+        return hasProp(cache.list, key)
+    };
+}
+
+const tagList = [
+    {
+        symbol: '-',
+        format(value) {
+            return `')\n${this.BUFFER}(${this.SAFE}(${value},1))\n${this.BUFFER}('`
+        },
+    },
+    {
+        symbol: '=',
+        format(value) {
+            return `')\n${this.BUFFER}(${this.SAFE}(${value}))\n${this.BUFFER}('`
+        },
+    },
+    {
+        symbol: '#',
+        format(value) {
+            return `')\n/**${value}**/\n${this.BUFFER}('`
+        },
+    },
+    {
+        symbol: '',
+        format(value) {
+            return `')\n${value.trim()}\n${this.BUFFER}('`
+        },
+    },
+];
+
+function matchTokens(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
+    });
+}
+
+function Compiler(config) {
+    if (instanceOf(this, Compiler) === false) return new Compiler(config)
+
+    const compiler = {};
+
+    this.configure = function (config) {
+        compiler.withObject = config.withObject;
+        compiler.rmWhitespace = config.rmWhitespace;
+        compiler.token = config.token;
+        compiler.vars = config.vars;
+        compiler.globalHelpers = config.globalHelpers;
+        compiler.matches = [];
+        compiler.formats = [];
+        compiler.slurp = {
+            match: '[ \\t]*',
+            start: [compiler.token.start, '_'],
+            end: ['_', compiler.token.end],
+        };
+        tagList.forEach((item) => {
+            compiler.matches.push(
+                compiler.token.start
+                    .concat(item.symbol)
+                    .concat(compiler.token.regex)
+                    .concat(compiler.token.end)
+            );
+            compiler.formats.push(item.format.bind(compiler.vars));
+        });
+        compiler.regex = new RegExp(
+            compiler.matches.join('|').concat('|$'),
+            'g'
+        );
+        compiler.slurpStart = new RegExp(
+            [compiler.slurp.match, compiler.slurp.start.join('')].join(''),
+            'gm'
+        );
+        compiler.slurpEnd = new RegExp(
+            [compiler.slurp.end.join(''), compiler.slurp.match].join(''),
+            'gm'
+        );
+    };
+
+    this.compile = function (content, path) {
+        const { SCOPE, SAFE, BUFFER, COMPONENT } = compiler.vars;
+        const GLOBALS = compiler.globalHelpers;
+        content = String(content);
+        if (compiler.rmWhitespace) {
+            content = content
+                .replace(/[\r\n]+/g, '\n')
+                .replace(/^\s+|\s+$/gm, '');
+        }
+        content = content
+            .replace(compiler.slurpStart, compiler.token.start)
+            .replace(compiler.slurpEnd, compiler.token.end);
+        let source = `${BUFFER}('`;
+        matchTokens(compiler.regex, content, (params, index, offset) => {
+            source += symbols(content.slice(index, offset));
+            params.forEach((value, index) => {
+                if (value) {
+                    source += compiler.formats[index](value);
+                }
+            });
+        });
+        source += `');`;
+        source = `try{${source}}catch(e){console.info(e)}`;
+        if (compiler.withObject) {
+            source = `with(${SCOPE}){${source}}`;
+        }
+        source = `${BUFFER}.start();${source}return ${BUFFER}.end();`;
+        source += `\n//# sourceURL=${path}`;
+        let result = null;
+        let params = [SCOPE, COMPONENT, BUFFER, SAFE].concat(GLOBALS);
+        try {
+            result = Function.apply(null, params.concat(source));
+            result.source = `(function(${params.join(',')}){\n${source}\n})`;
+        } catch (e) {
+            e.filename = path;
+            e.source = source;
+            throw e
+        }
+        return result
+    };
+
+    this.configure(config);
+}
+
+function Template(config, cache, compiler) {
+    if (instanceOf(this, Template) === false)
+        return new Template(config, cache, compiler)
+
+    if (instanceOf(cache, Cache) === false)
+        throw new TypeError('cache is not instance of Cache')
+
+    if (instanceOf(compiler, Compiler) === false)
+        throw new TypeError('compiler is not instance of Compiler')
+
+    const template = {};
+
+    const result = (template, content) => {
+        cache.set(template, content);
+        return content
+    };
+
+    const resolve = (path) => {
+        return template.resolver(template.path, path)
+    };
+
+    const compile = (content, template) => {
+        if (isFunction(content)) {
+            return content
+        } else {
+            return compiler.compile(content, template)
+        }
+    };
+
+    this.configure = function (config) {
+        template.path = config.path;
+        template.cache = config.cache;
+        if (isFunction(config.resolver)) {
+            template.resolver = config.resolver;
+        }
+    };
+
+    this.get = function (template) {
+        if (cache.exist(template)) {
+            return cache.resolve(template)
+        }
+        return resolve(template).then((content) =>
+            result(template, compile(content, template))
+        )
+    };
+    this.configure(config);
+}
+
+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 = '>';
+
+const 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('')
+};
+
+function resolve(list) {
+    return Promise.all(list || []).then((list) => list.join(''))
+}
+
+function createBuffer() {
+    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.error = function (e) {
+        throw e
+    };
+    buffer.end = function () {
+        return resolve(array)
+    };
+    return buffer
+}
+
+function Context(config) {
+    if (instanceOf(this, Context) === false) return new Context(config)
+    this.configure = function (config, methods) {
+        const { BLOCKS, MACRO, EXTEND, LAYOUT, BUFFER, COMPONENT } = config.vars;
+
+        this.create = function (data) {
+            return new Scope(data)
+        };
+
+        this.helpers = function (methods) {
+            extend(Scope.prototype, methods || {});
+        };
+
+        function Scope(data) {
+            this[BLOCKS] = {};
+            this[MACRO] = {};
+            extend(this, data || {});
+        }
+
+        Scope.prototype = extend({}, methods || {});
+        Object.defineProperties(Scope.prototype, {
+            [BUFFER]: {
+                value: createBuffer(),
+                writable: true,
+                configurable: false,
+                enumerable: false,
+            },
+            [BLOCKS]: {
+                value: {},
+                writable: true,
+                configurable: false,
+                enumerable: false,
+            },
+            [MACRO]: {
+                value: {},
+                writable: true,
+                configurable: false,
+                enumerable: false,
+            },
+            [LAYOUT]: {
+                value: false,
+                writable: true,
+                configurable: false,
+                enumerable: false,
+            },
+            [EXTEND]: {
+                value: false,
+                writable: true,
+                configurable: false,
+                enumerable: false,
+            },
+            getMacro: {
+                value() {
+                    return this[MACRO]
+                },
+                writable: false,
+                configurable: false,
+                enumerable: false,
+            },
+            getBuffer: {
+                value() {
+                    return this[BUFFER]
+                },
+                writable: false,
+                configurable: false,
+                enumerable: false,
+            },
+            getComponent: {
+                value() {
+                    const context = this;
+                    if (COMPONENT in context) {
+                        return function () {
+                            return context[COMPONENT].apply(context, arguments)
+                        }
+                    }
+                    return function () {
+                        console.log('%s function not defined', COMPONENT);
+                    }
+                },
+                writable: false,
+                configurable: false,
+                enumerable: false,
+            },
+            getBlocks: {
+                value() {
+                    return this[BLOCKS]
+                },
+                writable: false,
+                configurable: false,
+                enumerable: false,
+            },
+            setExtend: {
+                value(value) {
+                    this[EXTEND] = value;
+                },
+                writable: false,
+                configurable: false,
+                enumerable: false,
+            },
+            getExtend: {
+                value() {
+                    return this[EXTEND]
+                },
+                writable: false,
+                configurable: false,
+                enumerable: false,
+            },
+            setLayout: {
+                value(layout) {
+                    this[LAYOUT] = layout;
+                },
+                writable: false,
+                configurable: false,
+                enumerable: false,
+            },
+            getLayout: {
+                value() {
+                    return this[LAYOUT]
+                },
+                writable: false,
+                configurable: false,
+                enumerable: false,
+            },
+            clone: {
+                value(exclude_blocks) {
+                    const filter = [LAYOUT, EXTEND, BUFFER];
+                    if (exclude_blocks === true) {
+                        filter.push(BLOCKS);
+                    }
+                    return omit(this, filter)
+                },
+                writable: false,
+                configurable: false,
+                enumerable: false,
+            },
+
+            extend: {
+                value(layout) {
+                    this.setExtend(true);
+                    this.setLayout(layout);
+                },
+                writable: false,
+                configurable: false,
+                enumerable: false,
+            },
+            echo: {
+                value(layout) {
+                    const buffer = this.getBuffer();
+                    const params = [].slice.call(arguments);
+                    params.forEach(buffer);
+                },
+                writable: false,
+                configurable: false,
+                enumerable: false,
+            },
+            fn: {
+                value(callback) {
+                    const buffer = this.getBuffer();
+                    const context = this;
+                    return function () {
+                        buffer.backup();
+                        if (isFunction(callback)) {
+                            callback.apply(context, arguments);
+                        }
+                        return buffer.restore()
+                    }
+                },
+                writable: false,
+                configurable: false,
+                enumerable: false,
+            },
+            get: {
+                value(name, defaults) {
+                    const path = getPath(this, name, true);
+                    const result = path.shift();
+                    const prop = path.pop();
+                    return hasProp(result, prop) ? result[prop] : defaults
+                },
+                writable: false,
+                configurable: false,
+                enumerable: false,
+            },
+            set: {
+                value(name, value) {
+                    const path = getPath(this, name, false);
+                    const result = path.shift();
+                    const prop = path.pop();
+                    if (this.getExtend() && hasProp(result, prop)) {
+                        return result[prop]
+                    }
+                    return (result[prop] = value)
+                },
+                writable: false,
+                configurable: false,
+                enumerable: false,
+            },
+            macro: {
+                value(name, callback) {
+                    const list = this.getMacro();
+                    const macro = this.fn(callback);
+                    const context = this;
+                    list[name] = function () {
+                        return context.echo(macro.apply(undefined, arguments))
+                    };
+                },
+                writable: false,
+                configurable: false,
+                enumerable: false,
+            },
+            call: {
+                value(name) {
+                    const list = this.getMacro();
+                    const macro = list[name];
+                    const params = [].slice.call(arguments, 1);
+                    if (isFunction(macro)) {
+                        return macro.apply(macro, params)
+                    }
+                },
+                writable: false,
+                configurable: false,
+                enumerable: false,
+            },
+            block: {
+                value(name, callback) {
+                    const blocks = this.getBlocks();
+                    blocks[name] = blocks[name] || [];
+                    blocks[name].push(this.fn(callback));
+                    if (this.getExtend()) return
+                    const list = Object.assign([], blocks[name]);
+                    const current = function () {
+                        return list.shift()
+                    };
+                    const next = () => {
+                        const parent = current();
+                        if (parent) {
+                            return () => {
+                                this.echo(parent(next()));
+                            }
+                        } else {
+                            return noop
+                        }
+                    };
+                    this.echo(current()(next()));
+                },
+                writable: false,
+                configurable: false,
+                enumerable: false,
+            },
+            include: {
+                value(path, data, cx) {
+                    const context = cx === false ? {} : this.clone(true);
+                    const params = extend(context, data || {});
+                    const promise = this.render(path, params);
+                    this.echo(promise);
+                },
+                writable: false,
+                configurable: false,
+                enumerable: false,
+            },
+            use: {
+                value(path, namespace) {
+                    const promise = this.require(path);
+                    this.echo(
+                        resolve$1(
+                            promise,
+                            function (exports) {
+                                const list = this.getMacro();
+                                each(exports, function (macro, name) {
+                                    list[[namespace, name].join('.')] = macro;
+                                });
+                            },
+                            this
+                        )
+                    );
+                },
+                writable: false,
+                configurable: false,
+                enumerable: false,
+            },
+            async: {
+                value(promise, callback) {
+                    this.echo(
+                        resolve$1(
+                            promise,
+                            function (data) {
+                                return this.fn(callback)(data)
+                            },
+                            this
+                        )
+                    );
+                },
+                writable: false,
+                configurable: false,
+                enumerable: false,
+            },
+            each: {
+                value: function (object, callback) {
+                    if (isString(object)) {
+                        object = this.get(object, []);
+                    }
+                    each(object, callback);
+                },
+                writable: false,
+                configurable: false,
+                enumerable: false,
+            },
+            element: {
+                value(tag, attr, content) {
+                    return element(tag, attr, content)
+                },
+                writable: false,
+                configurable: false,
+                enumerable: false,
+            },
+            el: {
+                value(tag, attr, content) {
+                    if (isFunction(content)) {
+                        content = this.fn(content)();
+                    }
+                    this.echo(
+                        resolve$1(
+                            content,
+                            function (content) {
+                                return this.element(tag, attr, content)
+                            },
+                            this
+                        )
+                    );
+                },
+                writable: false,
+                configurable: false,
+                enumerable: false,
+            },
+        });
+    };
+    this.configure(config);
+}
+
+function EJS(options) {
+    if (instanceOf(this, EJS) === false) return new EJS(options)
+
+    const scope = {};
+    const config = {};
+
+    configSchema(config, options || {});
+
+    const context = new Context(config);
+    const compiler = new Compiler(config);
+    const cache = new Cache();
+    const template = new Template(config, cache, compiler);
+
+    const output = (path, context) => {
+        const params = [
+            context,
+            context.getComponent(),
+            context.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)
+        })
+    };
+    const require = (name) => {
+        const filepath = ext(name, config.extension);
+        const scope = context.create({});
+        return output(filepath, scope).then(() => {
+            return scope.getMacro()
+        })
+    };
+    const render = (name, data) => {
+        const filepath = ext(name, config.extension);
+        const scope = context.create(data);
+        return output(filepath, scope).then((content) => {
+            if (scope.getExtend()) {
+                scope.setExtend(false);
+                const layout = scope.getLayout();
+                const data = scope.clone();
+                return render(layout, data)
+            }
+            return content
+        })
+    };
+    this.configure = function (options) {
+        options = options || {};
+        configSchema(config, options);
+        context.configure(config, scope);
+        compiler.configure(config);
+        cache.configure(config);
+        template.configure(config);
+        return config
+    };
+    this.render = function (name, data) {
+        return render(name, data)
+    };
+    this.helpers = function (methods) {
+        context.helpers(extend(scope, methods));
+    };
+    this.preload = function (list) {
+        return cache.load(list || {})
+    };
+    this.create = function (options) {
+        return new EJS(options)
+    };
+    this.compile = function (content, path) {
+        return compiler.compile(content, path)
+    };
+    this.context = function (data) {
+        return context.create(data)
+    };
+    this.helpers({ require, render });
+    return this
+}
+
+const templates = {};
+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])
+    },
+});
+
+async function useTemplates(list) {
+    Object.assign(templates, list || {});
+}
+
+const { render, context, compile, helpers, preload, configure, create } = ejs;
+
+export { compile, configure, context, create, helpers, preload, render, useTemplates };