initial

2026-06-05 16:42:27 +03:00 · 2018-06-04 23:18:50 +02:00
parent d4a41482d3
commit edf90de445
18 changed files with 2403 additions and 0 deletions
@@ -0,0 +1,182 @@
+const Tokenizer = require("./Tokenizer");
+const TokenType = Tokenizer.TYPE;
+const TokenChar = Tokenizer.CHAR;
+const getCharCode = Tokenizer.getCharCode;
+
+const isTextToken = (token) => {
+    const type = token[Tokenizer.TOKEN.TYPE_ID];
+
+    return type === TokenType.SPACE || type === TokenType.NEW_LINE || type === TokenType.WORD
+};
+
+const isTagToken = (token) => token[Tokenizer.TOKEN.TYPE_ID] === TokenType.TAG;
+
+const isTagStart = (token) => !isTagEnd(token);
+
+const isTagEnd = (token) => getTokenValue(token).charCodeAt(0) === TokenChar.SLASH;
+
+const isAttrNameToken = (token) => token[Tokenizer.TOKEN.TYPE_ID] === TokenType.ATTR_NAME;
+
+const isAttrValueToken = (token) => token[Tokenizer.TOKEN.TYPE_ID] === TokenType.ATTR_VALUE;
+
+const getTagName = (token) => {
+    const value = getTokenValue(token);
+
+    return isTagEnd(token) ? value.slice(1) : value
+};
+
+const convertTagToText = (token) => {
+    let text = getCharCode(TokenChar.OPEN_BRAKET);
+
+    if (isTagEnd(token)) {
+        text += getCharCode(TokenChar.SLASH)
+    }
+
+    text += getTokenValue(token);
+    text += getCharCode(TokenChar.CLOSE_BRAKET);
+
+    return text
+};
+
+const getTokenValue = (token) => token[Tokenizer.TOKEN.VALUE_ID];
+
+const createTagNode = (name, attrs = {}, content = []) => ({tag: name, attrs, content});
+
+/**
+ *
+{
+    tag: 'div',
+    attrs: {
+        class: 'foo'
+    },
+    content: ['hello world!']
+}
+ */
+module.exports = class Parser {
+    constructor(tokens, options = {}) {
+        this.tokens = tokens;
+        this.options = options
+    }
+
+    parse() {
+        const tokens = this.tokens;
+        const nodes = [];
+        const nestedNodes = [];
+        const curTags = [];
+        const curTagsAttrName = [];
+
+        const getCurTag = () => {
+            if (curTags.length) {
+                return curTags[curTags.length - 1]
+            }
+
+            return null
+        };
+
+        const createCurTag = (token) => {
+            curTags.push(createTagNode(getTokenValue(token)))
+        };
+
+        const clearCurTag = () => {
+            if (curTags.length) {
+                curTags.pop();
+
+                clearCurTagAttrName()
+            }
+        };
+
+        const getCurTagAttrName = () => {
+            if (curTagsAttrName.length) {
+                return curTagsAttrName[curTagsAttrName.length - 1]
+            }
+
+            return null
+        };
+
+        const createCurTagAttrName = (token) => {
+            curTagsAttrName.push(getTokenValue(token))
+        };
+
+        const clearCurTagAttrName = () => {
+            if (curTagsAttrName.length) {
+                curTagsAttrName.pop()
+            }
+        };
+
+        const getNodes = () => {
+            if (nestedNodes.length) {
+                const nestedNode = nestedNodes[nestedNodes.length - 1];
+                return nestedNode.content
+            }
+
+            return nodes
+        };
+
+        let token;
+        while (token = tokens.shift()) {
+            if (!token) {
+                continue;
+            }
+
+            if (isTagToken(token)) {
+                if (this.isAllowedTag(getTagName(token))) {
+                    // [tag]
+                    if (isTagStart(token)) {
+                        createCurTag(token);
+
+                        if (this.isCloseTag(getTokenValue(token))) {
+                            nestedNodes.push(getCurTag())
+                        } else {
+                            getNodes().push(getCurTag());
+                            clearCurTag()
+                        }
+                    }
+
+                    // [/tag]
+                    if (isTagEnd(token)) {
+                        clearCurTag();
+
+                        const lastNestedNode = nestedNodes.pop();
+
+                        if (lastNestedNode) {
+                            getNodes().push(lastNestedNode)
+                        } else {
+                            debugger;
+                            console.warn(`Inconsistent tag '${getTokenValue(token)}'`);
+                        }
+                    }
+                } else {
+                    getNodes().push(convertTagToText(token))
+                }
+            }
+
+            if (getCurTag()) {
+                if (isAttrNameToken(token)) {
+                    createCurTagAttrName(token);
+                    getCurTag().attrs[getCurTagAttrName()] = null
+                } else if (isAttrValueToken(token)) {
+                    getCurTag().attrs[getCurTagAttrName()] = getTokenValue(token);
+                    clearCurTagAttrName()
+                } else if (isTextToken(token)) {
+                    getCurTag().content.push(getTokenValue(token))
+                }
+            } else if (isTextToken(token)) {
+                getNodes().push(getTokenValue(token))
+            }
+        }
+
+        return nodes
+    }
+
+    isCloseTag(value) {
+        return this.options.closableTags && this.options.closableTags.indexOf(value) >= 0
+    }
+
+    isAllowedTag(value) {
+        if (this.options.allowOnlyTags && this.options.allowOnlyTags.length) {
+            return this.options.allowOnlyTags.indexOf(value) >= 0
+        }
+
+        return true
+    }
+};