@b-side/parser/lib/binder.js

HTML Parser used to parse HTML string and bind data to it.

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.Binder = void 0;
const element_1 = require("./element");
class Binder {
    constructor(elements, data) {
        this.data = data;
        this.build([elements]);
    }
    build(elements, dataModifier) {
        const data = Object.assign({}, dataModifier);
        elements.forEach((element) => {
            if (element instanceof element_1.bsIteration) {
                this.evalFor(element, data);
            }
            else if (element instanceof element_1.bsCondition) {
                this.evalIf(element, data);
            }
            else if (element instanceof element_1.bsExpression) {
                this.elvalExpression(element, data);
            }
            let parent = element.parent;
            while (parent && !parent.dom) {
                parent = parent.parent;
            }
            if (element instanceof element_1.bsNode) {
                this.setEvents(element, data);
                this.setAttributes(element, data);
            }
            this.build(element.childs, data);
            if (element.dependancies && element.parent) {
                element.parent.dependancies.merge(element.dependancies);
            }
        });
        return data;
    }
    setEvents(element, dataModifier) {
        for (const [, expression] of element.eventsMap.dynamic) {
            expression.eval(this.data, dataModifier);
            element.dependancies.merge(expression.dependancies);
        }
    }
    setAttributes(element, dataModifier) {
        for (const [, expression] of element.attributesMap.dynamic) {
            expression.eval(this.data, dataModifier);
            element.dependancies.merge(expression.dependancies);
        }
    }
    evalIf(element, dataModifier) {
        element.expression.eval(this.data, dataModifier);
        element.dependancies.merge(element.expression.dependancies);
    }
    evalFor(element, dataModifier) {
        if (!element.expression) {
            return dataModifier;
        }
        const matches = element.expression.raw.matchAll(/^([a-z0-9]*)\s*,?\s*([a-z0-9]+)?\s+(in|of)\s+([\s\S]+)$/gi);
        for (const match of matches) {
            const [, _variableName, _indexName, type, expression] = match;
            if (type !== 'of') {
                throw `Iterator type [${type}] not supported in expression [${element.expression.raw}].`;
            }
            const string = `
	let __e = null;
	try {
		__e = await (${expression})
	} catch(e) {
		if (e instanceof ReferenceError) {
			console.error(e.message, ' in expression "${expression
                .trim()
                .replace(/'/g, "\\'")}", in component <${this.data.nodeName}>.');
			return 0;
		}
	}
	
	let ___i = __e;
	let ___o = null;
	if (typeof (__e) === 'number') {
		___i = [...new Array(__e).keys()];
		___o = x => {return { "${_variableName}": ___i[x]${_indexName ? `, "${_indexName}": x` : ''} }};
	} else if (!(Symbol.iterator in Object(__e))) {
		if ((__e) instanceof Object) {
			___i = Object.getOwnPropertyNames(__e);
			___o = ___x => {return { "${_variableName}": __e[___i[___x]]${_indexName ? `, "${_indexName}": ___i[___x]` : ''} }};
		} else {
			throw \`Object ${expression.replace('`', '`')} is not iterable.\`;
		}
	} else {
		___o = ___x => {return { "${_variableName}": __e[___x]${_indexName ? `, "${_indexName}": ___x` : ''} }};
	}
	for (let x=0;x<___i.length;x++) {
		await ___c(___o(x), x);
	}
	return ___i.length;
`;
            element.expression.setExpressionNoReturn(string);
            element.expression.eval(this.data, dataModifier);
            element.expression.dependancies.add(_variableName);
            if (_indexName) {
                element.expression.dependancies.add(_indexName);
                dataModifier[_indexName] = null;
            }
            dataModifier[_variableName] = null;
            element.dependancies.merge(element.expression.dependancies);
        }
        return dataModifier;
    }
    elvalExpression(element, dataModifier) {
        element.expression.eval(this.data, dataModifier);
        element.dependancies.merge(element.expression.dependancies);
    }
}
exports.Binder = Binder;
//# sourceMappingURL=binder.js.map