@kosatyi/ejs 0.0.113 → 0.0.115

package/dist/types/index-BiIhwNBq.d.ts

@@ -0,0 +1,785 @@
+import { t as typeProp, f as isArrayOfVariables, g as isArray, d as isBoolean, c as isString, i as isFunction, b as bindContext, s as symbols, e as element, h as each, k as getPath, l as hasProp, o as omit, a as escapeValue } from './element-CEdJaM42.js';
+
+/**
+ * @type {EjsConfig}
+ */
+const ejsDefaults = {
+    precompiled: 'ejsPrecompiled',
+    cache: true,
+    path: 'views',
+    extension: 'ejs',
+    rmWhitespace: true,
+    strict: true,
+    resolver: (path, template) => {
+        return Promise.resolve(
+            ['resolver is not defined', path, template].join(' '),
+        )
+    },
+    globals: [],
+    vars: {
+        SCOPE: 'ejs',
+        COMPONENT: 'ui',
+        ELEMENT: 'el',
+        EXTEND: '$$e',
+        BUFFER: '$$a',
+        LAYOUT: '$$l',
+        BLOCKS: '$$b',
+        MACRO: '$$m',
+        SAFE: '$$v',
+    },
+    token: {
+        start: '<%',
+        end: '%>',
+        regex: '([\\s\\S]+?)',
+    },
+};
+
+const configSchema = (config, options) => {
+    return Object.assign(config, {
+        path: typeProp(isString, ejsDefaults.path, config.path, options.path),
+        precompiled: typeProp(
+            isString,
+            ejsDefaults.precompiled,
+            config.export,
+            options.export,
+        ),
+        resolver: typeProp(
+            isFunction,
+            ejsDefaults.resolver,
+            config.resolver,
+            options.resolver,
+        ),
+        extension: typeProp(
+            isString,
+            ejsDefaults.extension,
+            config.extension,
+            options.extension,
+        ),
+        strict: typeProp(
+            isBoolean,
+            ejsDefaults.strict,
+            config.strict,
+            options.strict,
+        ),
+        rmWhitespace: typeProp(
+            isBoolean,
+            ejsDefaults.rmWhitespace,
+            config.rmWhitespace,
+            options.rmWhitespace,
+        ),
+        cache: typeProp(
+            isBoolean,
+            ejsDefaults.cache,
+            config.cache,
+            options.cache,
+        ),
+        globals: typeProp(
+            isArray,
+            ejsDefaults.globals,
+            config.globals,
+            isArrayOfVariables(options.globals),
+        ),
+        token: Object.assign(
+            {},
+            ejsDefaults.token,
+            config.token,
+            options.token,
+        ),
+        vars: Object.assign({}, ejsDefaults.vars, config.vars, options.vars),
+    })
+};
+
+class EjsError extends Error {
+    constructor(code, content) {
+        super(content);
+        this.code = code;
+        if (content instanceof Error) {
+            this.stack = content.stack;
+            this.message = content.message;
+        }
+    }
+}
+
+const error = (code, content) => {
+    throw new EjsError(code, content)
+};
+
+class EjsTemplate {
+    #path
+    #resolver
+    #cache
+    #compiler
+    static exports = ['configure', 'get']
+    constructor(options, cache, compiler) {
+        bindContext(this, this.constructor.exports);
+        this.#cache = cache;
+        this.#compiler = compiler;
+        this.configure(options ?? {});
+    }
+    configure(options) {
+        this.#path = options.path;
+        if (isFunction(options.resolver)) {
+            this.#resolver = options.resolver;
+        }
+    }
+    #resolve(template) {
+        const cached = this.#cache.get(template);
+        if (cached instanceof Promise) return cached
+        const result = Promise.resolve(
+            this.#resolver(this.#path, template, error),
+        );
+        this.#cache.set(template, result);
+        return result
+    }
+    #compile(content, template) {
+        const cached = this.#cache.get(template);
+        if (typeof cached === 'function') return cached
+        if (typeof content === 'string') {
+            content = this.#compiler.compile(content, template);
+        }
+        if (typeof content === 'function') {
+            this.#cache.set(template, content);
+            return content
+        }
+    }
+    get(template) {
+        return this.#resolve(template).then((content) => {
+            return this.#compile(content, template)
+        })
+    }
+}
+
+const tokenList = [
+    ['-', (v, b, s) => `')\n${b}(${s}(${v},1))\n${b}('`],
+    ['=', (v, b, s) => `')\n${b}(${s}(${v}))\n${b}('`],
+    ['#', (v, b) => `')\n/**${v}**/\n${b}('`],
+    ['', (v, b) => `')\n${v}\n${b}('`],
+];
+
+const tokensMatch = (regex, content, callback) => {
+    let index = 0;
+    content.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
+    });
+};
+
+class EjsCompiler {
+    #config = {}
+    static exports = ['configure', 'compile']
+    constructor(options) {
+        bindContext(this, this.constructor.exports);
+        this.configure(options);
+    }
+    configure(options) {
+        this.#config.strict = options.strict;
+        this.#config.rmWhitespace = options.rmWhitespace;
+        this.#config.token = options.token;
+        this.#config.vars = options.vars;
+        this.#config.globals = options.globals;
+        this.#config.legacy = options.legacy ?? true;
+        this.#config.slurp = {
+            match: '[s\t\n]*',
+            start: [this.#config.token.start, '_'],
+            end: ['_', this.#config.token.end],
+        };
+        this.#config.matches = [];
+        this.#config.formats = [];
+        for (const [symbol, format] of tokenList) {
+            this.#config.matches.push(
+                this.#config.token.start
+                    .concat(symbol)
+                    .concat(this.#config.token.regex)
+                    .concat(this.#config.token.end),
+            );
+            this.#config.formats.push(format);
+        }
+        this.#config.regex = new RegExp(
+            this.#config.matches.join('|').concat('|$'),
+            'g',
+        );
+        this.#config.slurpStart = new RegExp(
+            [this.#config.slurp.match, this.#config.slurp.start.join('')].join(
+                '',
+            ),
+            'gm',
+        );
+        this.#config.slurpEnd = new RegExp(
+            [this.#config.slurp.end.join(''), this.#config.slurp.match].join(
+                '',
+            ),
+            'gm',
+        );
+        if (this.#config.globals.length) {
+            if (this.#config.legacy) {
+                this.#config.globalVariables = `const ${this.#config.globals
+                    .map((name) => `${name}=${this.#config.vars.SCOPE}.${name}`)
+                    .join(',')};`;
+            } else {
+                this.#config.globalVariables = `const {${this.#config.globals.join(',')}} = ${this.#config.vars.SCOPE};`;
+            }
+        }
+    }
+    compile(content, path) {
+        const GLOBALS = this.#config.globalVariables;
+        const { SCOPE, SAFE, BUFFER, COMPONENT, ELEMENT } = this.#config.vars;
+        if (this.#config.rmWhitespace) {
+            content = String(content)
+                .replace(/[\r\n]+/g, '\n')
+                .replace(/^\s+|\s+$/gm, '');
+        }
+        content = String(content)
+            .replace(this.#config.slurpStart, this.#config.token.start)
+            .replace(this.#config.slurpEnd, this.#config.token.end);
+        let OUTPUT = `${BUFFER}('`;
+        tokensMatch(this.#config.regex, content, (params, index, offset) => {
+            OUTPUT += symbols(content.slice(index, offset));
+            params.forEach((value, index) => {
+                if (value) {
+                    OUTPUT += this.#config.formats[index](
+                        value.trim(),
+                        BUFFER,
+                        SAFE,
+                    );
+                }
+            });
+        });
+        OUTPUT += `');`;
+        OUTPUT = `try{${OUTPUT}}catch(e){return ${BUFFER}.error(e)}`;
+        if (this.#config.strict === false) {
+            OUTPUT = `with(${SCOPE}){${OUTPUT}}`;
+        }
+        OUTPUT = `${BUFFER}.start();${OUTPUT}return ${BUFFER}.end();`;
+        OUTPUT += `\n//# sourceURL=${path}`;
+        if (GLOBALS) {
+            OUTPUT = `${GLOBALS}\n${OUTPUT}`;
+        }
+        try {
+            const params = [SCOPE, COMPONENT, ELEMENT, BUFFER, SAFE];
+            const result = Function.apply(null, params.concat(OUTPUT));
+            result.source = `(function(${params.join(',')}){\n${OUTPUT}\n});`;
+            return result
+        } catch (e) {
+            e.filename = path;
+            e.source = OUTPUT;
+            error(0, e);
+        }
+    }
+}
+
+class EjsCache {
+    static exports = [
+        'load',
+        'set',
+        'get',
+        'exist',
+        'clear',
+        'remove',
+        'resolve',
+    ]
+    #cache = true
+    #precompiled
+    #list = {}
+    constructor(options) {
+        bindContext(this, this.constructor.exports);
+        this.configure(options);
+    }
+    get(key) {
+        if (this.#cache) {
+            return this.#list[key]
+        }
+    }
+    set(key, value) {
+        if (this.#cache) {
+            this.#list[key] = value;
+        }
+    }
+    exist(key) {
+        if (this.#cache) {
+            return this.#list.hasOwnProperty(key)
+        }
+    }
+    clear() {
+        Object.keys(this.#list).forEach(this.remove);
+    }
+    remove(key) {
+        delete this.#list[key];
+    }
+    resolve(key) {
+        return Promise.resolve(this.get(key))
+    }
+    load(data) {
+        if (this.#cache) {
+            Object.assign(this.#list, data || {});
+        }
+    }
+    configure(options) {
+        this.#cache = options.cache;
+        this.#precompiled = options.precompiled;
+        if (typeof window === 'object') {
+            this.load(window[this.#precompiled]);
+        }
+    }
+}
+
+const resolve = (list) => {
+    return Promise.all(list || [])
+        .then((list) => list.join(''))
+        .catch((e) => error(0, e))
+};
+
+const reject = (e) => {
+    return Promise.reject(error(0, e))
+};
+
+const EjsBuffer = () => {
+    let store = [];
+    let array = [];
+    /**
+     *
+     * @param value
+     * @constructor
+     */
+    const EjsBuffer = (value) => {
+        array.push(value);
+    };
+    EjsBuffer.start = () => {
+        array = [];
+    };
+    EjsBuffer.backup = () => {
+        store.push(array.concat());
+        array = [];
+    };
+    EjsBuffer.restore = () => {
+        const result = array.concat();
+        array = store.pop();
+        return resolve(result)
+    };
+    EjsBuffer.error = (e) => {
+        return reject(e)
+    };
+    EjsBuffer.end = () => {
+        return resolve(array)
+    };
+    return EjsBuffer
+};
+
+const PARENT = Symbol('EjsContext.parentTemplate');
+
+const createContext = (config, methods) => {
+    const globals = config.globals || [];
+    const {
+        BLOCKS,
+        MACRO,
+        EXTEND,
+        LAYOUT,
+        BUFFER,
+        SAFE,
+        SCOPE,
+        COMPONENT,
+        ELEMENT,
+    } = config.vars;
+    class Context {
+        constructor(data) {
+            this[PARENT] = null;
+            this[BLOCKS] = {};
+            this[MACRO] = {};
+            Object.assign(
+                this,
+                omit(data, [SCOPE, BUFFER, SAFE, COMPONENT, ELEMENT]),
+            );
+        }
+    }
+    Object.defineProperties(Context.prototype, {
+        [BUFFER]: {
+            value: EjsBuffer(),
+        },
+        [BLOCKS]: {
+            value: {},
+            writable: true,
+        },
+        [MACRO]: {
+            value: {},
+            writable: true,
+        },
+        [LAYOUT]: {
+            value: false,
+            writable: true,
+        },
+        [EXTEND]: {
+            value: false,
+            writable: true,
+        },
+        [PARENT]: {
+            value: null,
+            writable: true,
+        },
+        setParentTemplate: {
+            value(value) {
+                this[PARENT] = value;
+                return this
+            },
+        },
+        getParentTemplate: {
+            value() {
+                return this[PARENT]
+            },
+        },
+        useEscapeValue: {
+            value() {
+                return escapeValue
+            },
+        },
+        useComponent: {
+            value() {
+                if (isFunction(this[COMPONENT])) {
+                    return this[COMPONENT].bind(this)
+                } else {
+                    return function () {
+                        error(2, `${COMPONENT} must be a function`);
+                    }
+                }
+            },
+        },
+        useElement: {
+            value() {
+                if (isFunction(this[ELEMENT])) {
+                    return this[ELEMENT].bind(this)
+                } else {
+                    return () => {
+                        error(2, `${ELEMENT} must be a function`);
+                    }
+                }
+            },
+        },
+        useBuffer: {
+            value() {
+                return this[BUFFER]
+            },
+        },
+        getMacro: {
+            value() {
+                return this[MACRO]
+            },
+        },
+        getBlocks: {
+            value() {
+                return this[BLOCKS]
+            },
+        },
+        setExtend: {
+            value(value) {
+                this[EXTEND] = value;
+                return this
+            },
+        },
+        getExtend: {
+            value() {
+                return this[EXTEND]
+            },
+        },
+        setLayout: {
+            value(layout) {
+                this[LAYOUT] = layout;
+                return this
+            },
+        },
+        getLayout: {
+            value() {
+                return this[LAYOUT]
+            },
+        },
+        clone: {
+            value(exclude_blocks) {
+                const filter = [LAYOUT, EXTEND, BUFFER];
+                if (exclude_blocks === true) {
+                    filter.push(BLOCKS);
+                }
+                return omit(this, filter)
+            },
+        },
+        extend: {
+            value(layout) {
+                this.setExtend(true);
+                this.setLayout(layout);
+            },
+        },
+        echo: {
+            value() {
+                return [].slice.call(arguments).forEach(this.useBuffer())
+            },
+        },
+        fn: {
+            value(callback) {
+                const buffer = this.useBuffer();
+                const context = this;
+                return function () {
+                    if (isFunction(callback)) {
+                        buffer.backup();
+                        buffer(callback.apply(context, arguments));
+                        return buffer.restore()
+                    }
+                }
+            },
+        },
+        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))
+                };
+            },
+        },
+        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)
+                }
+            },
+        },
+        block: {
+            value(name, callback) {
+                const blocks = this.getBlocks();
+                blocks[name] = blocks[name] || [];
+                blocks[name].push(this.fn(callback));
+                if (this.getExtend()) return
+                const context = this;
+                const list = Object.assign([], blocks[name]);
+                const shift = function () {
+                    return list.shift()
+                };
+                const next = function () {
+                    const parent = shift();
+                    if (parent) {
+                        return function () {
+                            context.echo(parent(next()));
+                        }
+                    } else {
+                        return function () {}
+                    }
+                };
+                this.echo(shift()(next()));
+            },
+        },
+        hasBlock: {
+            value(name) {
+                return this.getBlocks().hasOwnProperty(name)
+            },
+        },
+        include: {
+            value(path, data, cx) {
+                const context = cx === false ? {} : this.clone(true);
+                const params = Object.assign(context, data || {});
+                const promise = this.render(path, params);
+                this.echo(promise);
+            },
+        },
+        use: {
+            value(path, namespace) {
+                this.echo(
+                    Promise.resolve(this.require(path)).then((exports$1) => {
+                        const list = this.getMacro();
+                        each(exports$1, (macro, name) => {
+                            list[[namespace, name].join('.')] = macro;
+                        });
+                    }),
+                );
+            },
+        },
+        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
+            },
+        },
+        set: {
+            value(name, value) {
+                const path = getPath(this, name, false);
+                const result = path.shift();
+                const prop = path.pop();
+                if (this.getParentTemplate() && hasProp(result, prop)) {
+                    return result[prop]
+                }
+                return (result[prop] = value)
+            },
+        },
+        each: {
+            value(object, callback) {
+                if (isString(object)) {
+                    object = this.get(object, []);
+                }
+                each(object, callback);
+            },
+            writable: true,
+        },
+        el: {
+            value(tag, attr, content) {
+                content = isFunction(content) ? this.fn(content)() : content;
+                this.echo(
+                    Promise.resolve(content).then((content) =>
+                        element(tag, attr, content),
+                    ),
+                );
+            },
+            writable: true,
+        },
+        ui: {
+            value() {},
+            writable: true,
+        },
+        require: {
+            value() {},
+            writable: true,
+        },
+        render: {
+            value() {},
+            writable: true,
+        },
+    });
+    Object.entries(methods).forEach(([name, value]) => {
+        if (isFunction(value) && globals.includes(name)) {
+            value = value.bind(Context.prototype);
+        }
+        Context.prototype[name] = value;
+    });
+    return Context
+};
+
+class EjsContext {
+    #context
+    static exports = ['create', 'globals', 'helpers']
+    constructor(options, methods) {
+        bindContext(this, this.constructor.exports);
+        this.configure(options, methods);
+    }
+    create(data) {
+        return new this.#context(data)
+    }
+    helpers(methods) {
+        Object.assign(this.#context.prototype, methods);
+    }
+    configure(options, methods) {
+        this.#context = createContext(options, methods);
+    }
+}
+
+class EjsInstance {
+    #cache
+    #context
+    #compiler
+    #template
+    #config = {}
+    #methods = {}
+    static exports = [
+        'configure',
+        'create',
+        'createContext',
+        'render',
+        'require',
+        'preload',
+        'compile',
+        'helpers',
+    ]
+    /**
+     *
+     * @param {EjsConfig} options
+     */
+    constructor(options = {}) {
+        bindContext(this, this.constructor.exports);
+        this.#methods = {};
+        this.#config = configSchema({}, options);
+        this.#context = new EjsContext(this.#config, this.#methods);
+        this.#compiler = new EjsCompiler(this.#config);
+        this.#cache = new EjsCache(this.#config);
+        this.#template = new EjsTemplate(
+            this.#config,
+            this.#cache,
+            this.#compiler,
+        );
+        this.helpers({ render: this.render, require: this.require });
+    }
+    create(options) {
+        return new this.constructor(options)
+    }
+    configure(options) {
+        if (options) {
+            configSchema(this.#config, options);
+            this.#context.configure(this.#config, this.#methods);
+            this.#compiler.configure(this.#config);
+            this.#cache.configure(this.#config);
+            this.#template.configure(this.#config);
+        }
+        return this.#config
+    }
+    createContext(data) {
+        return this.#context.create(data)
+    }
+    preload(list) {
+        return this.#cache.load(list || {})
+    }
+    compile(content, path) {
+        return this.#compiler.compile(content, path)
+    }
+    helpers(methods) {
+        this.#context.helpers(Object.assign(this.#methods, methods));
+    }
+    async render(name, params) {
+        const data = this.createContext(params);
+        return this.#output(this.#path(name), data).then(
+            this.#outputContent(name, data),
+        )
+    }
+    async require(name) {
+        const data = this.createContext({});
+        return this.#output(this.#path(name), data).then(() => data.getMacro())
+    }
+    #path(name) {
+        const ext = name.split('.').pop();
+        if (ext !== this.#config.extension) {
+            name = [name, this.#config.extension].join('.');
+        }
+        return name
+    }
+    #output(path, data) {
+        return this.#template
+            .get(path)
+            .then((callback) =>
+                callback.apply(data, [
+                    data,
+                    data.useComponent(),
+                    data.useElement(),
+                    data.useBuffer(),
+                    data.useEscapeValue(),
+                ]),
+            )
+    }
+    #renderLayout(name, params, parentTemplate) {
+        const data = this.createContext(params);
+        if (parentTemplate) data.setParentTemplate(parentTemplate);
+        return this.#output(this.#path(name), data).then(
+            this.#outputContent(name, data),
+        )
+    }
+    #outputContent(name, data) {
+        return (content) => {
+            if (data.getExtend()) {
+                data.setExtend(false);
+                return this.#renderLayout(data.getLayout(), data, name)
+            }
+            return content
+        }
+    }
+}
+
+export { EjsInstance as E, ejsDefaults as e };