@jss-rule-engine/core/dist/src/ruleParser.js

Rule engine for Sitecore JSS

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var parse_xml_1 = require("@rgrove/parse-xml");
function parseUnionCondition(conditionXmlNode, ruleEngineContext) {
    var parsedCondition = {
        conditions: new Array(),
        className: conditionXmlNode.name
    };
    var childNodes = conditionXmlNode.children.filter(function (x) { return x.type == "element" && x.name == "condition"; });
    childNodes.forEach(function (ruleXmlNode) {
        var _a;
        var parsedRule = parseCondition(ruleXmlNode, ruleEngineContext);
        if (parsedRule) {
            (_a = parsedCondition.conditions) === null || _a === void 0 ? void 0 : _a.push(parsedRule);
        }
        else {
            throw new Error('Condition wasnt parsed' + ruleXmlNode);
        }
    });
    return parsedCondition;
}
function parseRegularCondition(conditionXmlNode, _ruleEngineContext) {
    var parsedCondition = {
        className: "condition",
        attributes: new Map()
    };
    var attributeKeys = Object.keys(conditionXmlNode.attributes);
    attributeKeys.forEach(function (attr) {
        switch (attr) {
            case 'id':
                parsedCondition.id = conditionXmlNode.attributes[attr];
            case 'except':
                parsedCondition.except = conditionXmlNode.attributes[attr] == 'true';
            default:
                parsedCondition.attributes.set(attr, conditionXmlNode.attributes[attr]);
        }
    });
    return parsedCondition;
}
function parseAction(actionXmlNode, _ruleEngineContext) {
    var parsedAction = {
        className: "action",
        attributes: new Map()
    };
    var attributeKeys = Object.keys(actionXmlNode === null || actionXmlNode === void 0 ? void 0 : actionXmlNode.attributes);
    attributeKeys.forEach(function (attr) {
        if (attr == 'id') {
            parsedAction.id = actionXmlNode.attributes[attr];
        }
        else {
            parsedAction.attributes.set(attr, actionXmlNode.attributes[attr]);
        }
    });
    return parsedAction;
}
function parseCondition(conditionXmlNode, ruleEngineContext) {
    if (conditionXmlNode.name == "or" || conditionXmlNode.name == "and") {
        return parseUnionCondition(conditionXmlNode, ruleEngineContext);
    }
    return parseRegularCondition(conditionXmlNode, ruleEngineContext);
}
function default_1(ruleXml, ruleEngineContext) {
    if (!ruleXml || ruleXml.length == 0) {
        return null;
    }
    ruleXml = ruleXml.replaceAll('\t', '').replaceAll('\n', '').replaceAll('\r', '');
    var xmlDoc = (0, parse_xml_1.parseXml)(ruleXml);
    var rulesetNode = xmlDoc.children.find(function (x) { return x.type == "element" && x.name == "ruleset"; });
    if (!rulesetNode ||
        !rulesetNode.children ||
        rulesetNode.type != "element" ||
        rulesetNode.name != "ruleset") {
        throw new Error("Ruleset node is missing.");
    }
    var parsedRule = {
        rules: []
    };
    var rulesNodes = rulesetNode.children.filter(function (x) {
        return x.type == "element" && x.name == "rule";
    });
    if (!rulesNodes) {
        console.log('Rule nodes are missing.');
        return null;
    }
    rulesNodes.forEach(function (ruleXmlNode) {
        var _a, _b;
        var rule = {
            conditions: [],
            actions: [],
            attributes: new Map()
        };
        var attributeKeys = Object.keys(ruleXmlNode.attributes);
        attributeKeys.forEach(function (attr) {
            var _a;
            (_a = rule.attributes) === null || _a === void 0 ? void 0 : _a.set(attr, ruleXmlNode.attributes[attr]);
        });
        var conditionsRootNode = ruleXmlNode.children.find(function (x) { return x.type == "element" && x.name == "conditions"; });
        if (conditionsRootNode && conditionsRootNode.children) {
            //ruleEngineContext.ruleEngine?.debugMessage(conditionsRootNode);
            conditionsRootNode.children.filter(function (x) { return x.type == "element"; }).forEach(function (conditionXmlNode) {
                var _a, _b;
                var parsedCondition = parseCondition(conditionXmlNode, ruleEngineContext);
                if (parsedCondition) {
                    (_a = ruleEngineContext.ruleEngine) === null || _a === void 0 ? void 0 : _a.debugMessage('Parsed condition element:');
                    (_b = rule.conditions) === null || _b === void 0 ? void 0 : _b.push(parsedCondition);
                }
                else {
                    throw new Error('Condition wasnt parsed ' + conditionXmlNode);
                }
            });
        }
        var actionsRootNode = ruleXmlNode.children.find(function (x) { return x.type == "element" && x.name == "actions"; });
        if (actionsRootNode && actionsRootNode.children) {
            (_a = ruleEngineContext.ruleEngine) === null || _a === void 0 ? void 0 : _a.debugMessage(actionsRootNode);
            actionsRootNode.children.filter(function (x) { return x.type == "element"; }).forEach(function (actionXmlNode) {
                var _a, _b;
                var parsedAction = parseAction(actionXmlNode, ruleEngineContext);
                if (parsedAction) {
                    (_a = ruleEngineContext.ruleEngine) === null || _a === void 0 ? void 0 : _a.debugMessage('Parsed action element:');
                    (_b = rule.actions) === null || _b === void 0 ? void 0 : _b.push(parsedAction);
                }
                else {
                    throw new Error('Condition wasnt parsed ' + actionXmlNode);
                }
            });
        }
        (_b = parsedRule.rules) === null || _b === void 0 ? void 0 : _b.push(rule);
    });
    return parsedRule;
}
exports.default = default_1;
//# sourceMappingURL=ruleParser.js.map