cst/lib/Traverse.js

JavaScript CST Implementation

'use strict';

Object.defineProperty(exports, '__esModule', {
    value: true
});

var _createClass = (function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ('value' in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })();

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } }

var Traverse = (function () {
    function Traverse() {
        _classCallCheck(this, Traverse);

        this._nodeIndex = new ElementIndexByType();
        this._tokenIndex = new ElementIndexByType();
    }

    _createClass(Traverse, [{
        key: 'selectNodesByType',
        value: function selectNodesByType(type) {
            return this._nodeIndex.select(type);
        }
    }, {
        key: 'selectTokensByType',
        value: function selectTokensByType(type) {
            return this._tokenIndex.select(type);
        }
    }, {
        key: 'selectTokensByTypeAndValue',
        value: function selectTokensByTypeAndValue(type, value) {
            var tokens = this._tokenIndex.select(type);

            if (value) {
                return tokens.filter(function (token) {
                    return token.value === value;
                });
            }

            return tokens;
        }
    }, {
        key: 'addElements',
        value: function addElements(elements) {
            var nodeIndex = this._nodeIndex;
            var tokenIndex = this._tokenIndex;

            for (var i = 0; i < elements.length; i++) {
                addElementTree(elements[i]);
            }

            function addElementTree(element) {
                if (element.isToken) {
                    tokenIndex.addElement(element);
                } else {
                    nodeIndex.addElement(element);
                    var child = element._firstChild;
                    while (child) {
                        addElementTree(child);
                        child = child._nextSibling;
                    }
                }
            }
        }
    }, {
        key: 'removeElements',
        value: function removeElements(elements) {
            var nodeIndex = this._nodeIndex;
            var tokenIndex = this._tokenIndex;

            for (var i = 0; i < elements.length; i++) {
                removeElementTree(elements[i]);
            }

            function removeElementTree(element) {
                if (element.isToken) {
                    tokenIndex.removeElement(element);
                } else {
                    nodeIndex.removeElement(element);
                    var child = element._firstChild;
                    while (child) {
                        removeElementTree(child);
                        child = child._nextSibling;
                    }
                }
            }
        }
    }]);

    return Traverse;
})();

exports['default'] = Traverse;

var ElementIndexByType = (function () {
    function ElementIndexByType() {
        _classCallCheck(this, ElementIndexByType);

        this._index = {};
    }

    _createClass(ElementIndexByType, [{
        key: 'select',
        value: function select(type) {
            var items = this._index[type];
            if (items) {
                return items.concat();
            } else {
                return [];
            }
        }
    }, {
        key: 'addElement',
        value: function addElement(element) {
            var items = this._index[element._type];
            if (!items) {
                items = this._index[element._type] = [];
            }
            items[items.length] = element;
        }
    }, {
        key: 'removeElement',
        value: function removeElement(element) {
            var items = this._index[element._type];
            items.splice(items.indexOf(element), 1);
        }
    }]);

    return ElementIndexByType;
})();

module.exports = exports['default'];