bbcode-compiler 0.1.5 → 0.1.7

package/src/parser/AstNode.ts

@@ -36,39 +36,32 @@ Attr <-
 import { nodeIsType } from './nodeIsType.js'
 
 // ----------------------------------------------------------------------------
-// AstNode
+// MARK: AstNode
 // ----------------------------------------------------------------------------
 
 export const enum AstNodeType {
-    RootNode,
-    TextNode,
-    LinebreakNode,
-    TagNode,
-    StartTagNode,
-    EndTagNode,
-    AttrNode,
+    RootNode = 'RootNode',
+    TextNode = 'TextNode',
+    LinebreakNode = 'LinebreakNode',
+    TagNode = 'TagNode',
+    StartTagNode = 'StartTagNode',
+    EndTagNode = 'EndTagNode',
+    AttrNode = 'AttrNode',
 }
 
-export function nodeTypeToString(nodeType: AstNodeType): string {
-    switch (nodeType) {
-        case AstNodeType.RootNode: return 'RootNode'
-        case AstNodeType.TextNode: return 'TextNode'
-        case AstNodeType.LinebreakNode: return 'LinebreakNode'
-        case AstNodeType.TagNode: return 'TagNode'
-        case AstNodeType.StartTagNode: return 'StartTagNode'
-        case AstNodeType.EndTagNode: return 'EndTagNode'
-        case AstNodeType.AttrNode: return 'AttrNode'
-    }
+export type AstNodeJson = {
+    type: AstNodeType
+    data?: Record<string, string | AstNodeJson>
+    children?: Array<AstNodeJson>
 }
 
 export abstract class AstNode {
     readonly abstract nodeType: AstNodeType
 
-    // eslint-disable-next-line no-use-before-define
-    readonly children: Array<AstNode>
-
-    constructor(children: Array<AstNode> = []) {
-        this.children = children
+    constructor(
+        readonly children: Array<AstNode> = [],
+    ) {
+        // nop
     }
 
     addChild(node: AstNode): void {
@@ -86,7 +79,7 @@ export abstract class AstNode {
     }
 
     toShortString(): string {
-        return nodeTypeToString(this.nodeType)
+        return this.nodeType
     }
 
     // For debugging purposes only
@@ -100,10 +93,22 @@ export abstract class AstNode {
 
         return s
     }
+
+    toJSON(): AstNodeJson {
+        const json: AstNodeJson = {
+            type: this.nodeType,
+        }
+
+        if (this.children.length > 0) {
+            json.children = this.children.map((child) => child.toJSON())
+        }
+
+        return json
+    }
 }
 
 // ----------------------------------------------------------------------------
-// Root
+// MARK: Root
 // ----------------------------------------------------------------------------
 
 export class RootNode extends AstNode {
@@ -123,7 +128,7 @@ export class RootNode extends AstNode {
 }
 
 // ----------------------------------------------------------------------------
-// Text
+// MARK: Text
 // ----------------------------------------------------------------------------
 
 export class TextNode extends AstNode {
@@ -142,6 +147,16 @@ export class TextNode extends AstNode {
     override toShortString(): string {
         return `${super.toShortString()} "${this.str}"`
     }
+
+    override toJSON(): AstNodeJson {
+        const json = super.toJSON()
+
+        json.data = {
+            str: this.str,
+        }
+
+        return json
+    }
 }
 
 export class LinebreakNode extends AstNode {
@@ -153,7 +168,100 @@ export class LinebreakNode extends AstNode {
 }
 
 // ----------------------------------------------------------------------------
-// Tag
+// MARK: Attr
+// ----------------------------------------------------------------------------
+
+export class AttrNode extends AstNode {
+    readonly nodeType = AstNodeType.AttrNode
+
+    static readonly DEFAULT_KEY = 'default'
+
+    get key(): string {
+        switch (this.children.length) {
+            case 1: {
+                return AttrNode.DEFAULT_KEY
+            }
+            case 2: {
+                if (!nodeIsType(this.children[0], AstNodeType.TextNode)) {
+                    throw new Error('Invalid TextNode')
+                }
+
+                return this.children[0].str.trim()
+            }
+        }
+
+        throw new Error('Invalid AttrNode')
+    }
+
+    get val(): string {
+        switch (this.children.length) {
+            case 1: {
+                if (!nodeIsType(this.children[0], AstNodeType.TextNode)) {
+                    throw new Error('Invalid TextNode')
+                }
+
+                return this.children[0].str.trim()
+            }
+            case 2: {
+                if (!nodeIsType(this.children[1], AstNodeType.TextNode)) {
+                    throw new Error('Invalid TextNode')
+                }
+
+                return this.children[1].str.trim()
+            }
+        }
+
+        throw new Error('Invalid AttrNode')
+    }
+
+    override isValid(): boolean {
+        return super.isValid() && (this.children.length >= 1 && this.children.length <= 2)
+    }
+
+    override toShortString(): string {
+        let s = super.toShortString()
+
+        switch (this.children.length) {
+            case 1: {
+                s += ` VAL="${this.val}"`
+                break
+            }
+            case 2: {
+                s += ` KEY="${this.key}" VAL="${this.val}"`
+                break
+            }
+        }
+
+        return s
+    }
+
+    override toJSON(): AstNodeJson {
+        const json: AstNodeJson = {
+            type: this.nodeType,
+        }
+
+        switch (this.children.length) {
+            case 1: {
+                json.data = {
+                    key: this.key,
+                }
+                break
+            }
+            case 2: {
+                json.data = {
+                    key: this.key,
+                    val: this.val,
+                }
+                break
+            }
+        }
+
+        return json
+    }
+}
+
+// ----------------------------------------------------------------------------
+// MARK: Tag
 // ----------------------------------------------------------------------------
 
 export class StartTagNode extends AstNode {
@@ -180,6 +288,16 @@ export class StartTagNode extends AstNode {
     override toShortString(): string {
         return `${super.toShortString()} ${this.ogTag}`
     }
+
+    override toJSON(): AstNodeJson {
+        const json = super.toJSON()
+
+        json.data = {
+            tag: this.tagName,
+        }
+
+        return json
+    }
 }
 
 export class EndTagNode extends AstNode {
@@ -200,6 +318,16 @@ export class EndTagNode extends AstNode {
     override toShortString(): string {
         return `${super.toShortString()} ${this.ogTag}`
     }
+
+    override toJSON(): AstNodeJson {
+        const json = super.toJSON()
+
+        json.data = {
+            tag: this.tagName,
+        }
+
+        return json
+    }
 }
 
 export class TagNode extends AstNode {
@@ -266,73 +394,18 @@ export class TagNode extends AstNode {
 
         return s
     }
-}
 
-// ----------------------------------------------------------------------------
-// Attr
-// ----------------------------------------------------------------------------
+    override toJSON(): AstNodeJson {
+        const json = super.toJSON()
 
-export class AttrNode extends AstNode {
-    readonly nodeType = AstNodeType.AttrNode
-
-    static readonly DEFAULT_KEY = 'default'
-
-    get key(): string {
-        switch (this.children.length) {
-            case 1: {
-                return AttrNode.DEFAULT_KEY
-            }
-            case 2: {
-                if (!nodeIsType(this.children[0], AstNodeType.TextNode)) {
-                    throw new Error('Invalid TextNode')
-                }
-
-                return this.children[0].str.trim()
-            }
+        json.data = {
+            startTag: this._startTag.toJSON(),
         }
 
-        throw new Error('Invalid AttrNode')
-    }
-
-    get val(): string {
-        switch (this.children.length) {
-            case 1: {
-                if (!nodeIsType(this.children[0], AstNodeType.TextNode)) {
-                    throw new Error('Invalid TextNode')
-                }
-
-                return this.children[0].str.trim()
-            }
-            case 2: {
-                if (!nodeIsType(this.children[1], AstNodeType.TextNode)) {
-                    throw new Error('Invalid TextNode')
-                }
-
-                return this.children[1].str.trim()
-            }
+        if (this._endTag) {
+            json.data.endTag = this._endTag.toJSON()
         }
 
-        throw new Error('Invalid AttrNode')
-    }
-
-    override isValid(): boolean {
-        return super.isValid() && (this.children.length >= 1 && this.children.length <= 2)
-    }
-
-    override toShortString(): string {
-        let s = super.toShortString()
-
-        switch (this.children.length) {
-            case 1: {
-                s += ` VAL="${this.val}"`
-                break
-            }
-            case 2: {
-                s += ` KEY="${this.key}" VAL="${this.val}"`
-                break
-            }
-        }
-
-        return s
+        return json
     }
 }

package/src/parser/Parser.ts

@@ -18,109 +18,6 @@ export class Parser {
     parse(ogText: string, tokens: Array<Token>): RootNode {
         let idx = 0
 
-        const parseRoot = (): RootNode => {
-            const root = new RootNode()
-
-            while (idx < tokens.length) {
-                if (tokens[idx].type === TokenType.L_BRACKET) {
-                    const startIdx = idx
-                    const tagNode = parseTag()
-
-                    if (tagNode !== null) {
-                        root.addChild(tagNode)
-                    } else {
-                        const invalidTokens = tokens.slice(startIdx, idx)
-                        const str = stringifyTokens(ogText, invalidTokens)
-                        const textNode = new TextNode(str)
-                        root.addChild(textNode)
-                    }
-                } else if (tokens[idx].type === TokenType.LINEBREAK) {
-                    idx += 1 // Consume LINEBREAK
-                    root.addChild(new LinebreakNode())
-                } else {
-                    const startIdx = idx
-
-                    // Advance until we see the start of another RootNode's child (TagNode or LinebreakNode)
-                    while (idx < tokens.length && tokens[idx].type !== TokenType.L_BRACKET && tokens[idx].type !== TokenType.LINEBREAK) {
-                        idx += 1
-                    }
-
-                    const slice = tokens.slice(startIdx, idx)
-                    const str = stringifyTokens(ogText, slice)
-                    root.addChild(new TextNode(str))
-                }
-            }
-
-            return root
-        }
-
-        const parseTag = (): StartTagNode | EndTagNode | null => {
-            if (idx + 1 >= tokens.length) {
-                return null
-            }
-
-            if (tokens[idx].type !== TokenType.L_BRACKET) {
-                return null
-            }
-
-            // If L_BRACKET is followed by text, then it must be StartTag or is invalid
-            if (isStringToken(tokens[idx + 1].type)) {
-                const startIdx = idx
-                idx += 1 // Consume L_BRACKET
-
-                const labelText = parseLabel()
-                if (!this.tags.has(labelText)) {
-                    return null
-                }
-
-                const attrNodes = new Array<AttrNode>()
-                while (true) {
-                    const attrNode = parseAttr()
-                    if (attrNode === null) {
-                        break
-                    }
-
-                    attrNodes.push(attrNode)
-                }
-
-                if (tokens[idx].type !== TokenType.R_BRACKET) {
-                    return null
-                }
-
-                idx += 1 // Consume R_BRACKET
-
-                const slice = tokens.slice(startIdx, idx)
-                const ogTag = stringifyTokens(ogText, slice)
-                const startTagNode = new StartTagNode(labelText, ogTag, attrNodes)
-                return startTagNode
-            }
-
-            // If L_BRACKET is followed by BACKSLASH, then it must be EndTag or is invalid
-            if (tokens[idx + 1].type === TokenType.BACKSLASH) {
-                const startIdx = idx
-                idx += 1 // Consume L_BRACKET
-                idx += 1 // Consume BACKSLASH
-
-                const labelText = parseLabel()
-                if (!this.tags.has(labelText)) {
-                    return null
-                }
-
-                if (tokens[idx].type !== TokenType.R_BRACKET) {
-                    return null
-                }
-
-                idx += 1 // Consume R_BRACKET
-
-                const slice = tokens.slice(startIdx, idx)
-                const ogTag = stringifyTokens(ogText, slice)
-                const endTagNode = new EndTagNode(labelText, ogTag)
-                return endTagNode
-            }
-
-            return null
-        }
-
         const parseLabel = (): string => {
             const slice = tokens.slice(idx, idx + 1)
             const label = stringifyTokens(ogText, slice)
@@ -243,6 +140,109 @@ export class Parser {
             return attrNode
         }
 
+        const parseTag = (): StartTagNode | EndTagNode | null => {
+            if (idx + 1 >= tokens.length) {
+                return null
+            }
+
+            if (tokens[idx].type !== TokenType.L_BRACKET) {
+                return null
+            }
+
+            // If L_BRACKET is followed by text, then it must be StartTag or is invalid
+            if (isStringToken(tokens[idx + 1].type)) {
+                const startIdx = idx
+                idx += 1 // Consume L_BRACKET
+
+                const labelText = parseLabel()
+                if (!this.tags.has(labelText)) {
+                    return null
+                }
+
+                const attrNodes = new Array<AttrNode>()
+                while (true) {
+                    const attrNode = parseAttr()
+                    if (attrNode === null) {
+                        break
+                    }
+
+                    attrNodes.push(attrNode)
+                }
+
+                if (tokens[idx].type !== TokenType.R_BRACKET) {
+                    return null
+                }
+
+                idx += 1 // Consume R_BRACKET
+
+                const slice = tokens.slice(startIdx, idx)
+                const ogTag = stringifyTokens(ogText, slice)
+                const startTagNode = new StartTagNode(labelText, ogTag, attrNodes)
+                return startTagNode
+            }
+
+            // If L_BRACKET is followed by BACKSLASH, then it must be EndTag or is invalid
+            if (tokens[idx + 1].type === TokenType.BACKSLASH) {
+                const startIdx = idx
+                idx += 1 // Consume L_BRACKET
+                idx += 1 // Consume BACKSLASH
+
+                const labelText = parseLabel()
+                if (!this.tags.has(labelText)) {
+                    return null
+                }
+
+                if (tokens[idx].type !== TokenType.R_BRACKET) {
+                    return null
+                }
+
+                idx += 1 // Consume R_BRACKET
+
+                const slice = tokens.slice(startIdx, idx)
+                const ogTag = stringifyTokens(ogText, slice)
+                const endTagNode = new EndTagNode(labelText, ogTag)
+                return endTagNode
+            }
+
+            return null
+        }
+
+        const parseRoot = (): RootNode => {
+            const root = new RootNode()
+
+            while (idx < tokens.length) {
+                if (tokens[idx].type === TokenType.L_BRACKET) {
+                    const startIdx = idx
+                    const tagNode = parseTag()
+
+                    if (tagNode !== null) {
+                        root.addChild(tagNode)
+                    } else {
+                        const invalidTokens = tokens.slice(startIdx, idx)
+                        const str = stringifyTokens(ogText, invalidTokens)
+                        const textNode = new TextNode(str)
+                        root.addChild(textNode)
+                    }
+                } else if (tokens[idx].type === TokenType.LINEBREAK) {
+                    idx += 1 // Consume LINEBREAK
+                    root.addChild(new LinebreakNode())
+                } else {
+                    const startIdx = idx
+
+                    // Advance until we see the start of another RootNode's child (TagNode or LinebreakNode)
+                    while (idx < tokens.length && tokens[idx].type !== TokenType.L_BRACKET && tokens[idx].type !== TokenType.LINEBREAK) {
+                        idx += 1
+                    }
+
+                    const slice = tokens.slice(startIdx, idx)
+                    const str = stringifyTokens(ogText, slice)
+                    root.addChild(new TextNode(str))
+                }
+            }
+
+            return root
+        }
+
         let root = parseRoot()
         root = this.matchTagNodes(root)
         return root

package/dist/generateHtml.js

@@ -1,13 +0,0 @@
-import { Generator } from './generator/Generator.js';
-import { htmlTransforms } from './generator/transforms/htmlTransforms.js';
-import { Lexer } from './lexer/Lexer.js';
-import { Parser } from './parser/Parser.js';
-export function generateHtml(input, transforms = htmlTransforms) {
-    const lexer = new Lexer();
-    const tokens = lexer.tokenize(input);
-    const parser = new Parser(transforms);
-    const root = parser.parse(input, tokens);
-    const generator = new Generator(transforms);
-    return generator.generate(root);
-}
-//# sourceMappingURL=generateHtml.js.map

package/dist/generateHtml.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"generateHtml.js","sourceRoot":"","sources":["../src/generateHtml.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,0BAA0B,CAAA;AACpD,OAAO,EAAE,cAAc,EAAE,MAAM,0CAA0C,CAAA;AACzE,OAAO,EAAE,KAAK,EAAE,MAAM,kBAAkB,CAAA;AACxC,OAAO,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAA;AAE3C,MAAM,UAAU,YAAY,CAAC,KAAa,EAAE,UAAU,GAAG,cAAc;IACnE,MAAM,KAAK,GAAG,IAAI,KAAK,EAAE,CAAA;IACzB,MAAM,MAAM,GAAG,KAAK,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAA;IAEpC,MAAM,MAAM,GAAG,IAAI,MAAM,CAAC,UAAU,CAAC,CAAA;IACrC,MAAM,IAAI,GAAG,MAAM,CAAC,KAAK,CAAC,KAAK,EAAE,MAAM,CAAC,CAAA;IAExC,MAAM,SAAS,GAAG,IAAI,SAAS,CAAC,UAAU,CAAC,CAAA;IAC3C,OAAO,SAAS,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAA;AACnC,CAAC"}

package/dist/generator/Generator.js

@@ -1,54 +0,0 @@
-import { nodeIsType } from '../parser/nodeIsType.js';
-import { htmlTransforms } from './transforms/htmlTransforms.js';
-export class Generator {
-    transforms;
-    constructor(transforms = htmlTransforms) {
-        this.transforms = new Map(transforms.map((transform) => [transform.name, transform]));
-    }
-    generate(root) {
-        const stringify = (node) => {
-            let output = '';
-            if (nodeIsType(node, 3 /* AstNodeType.TagNode */)) {
-                const tagName = node.tagName;
-                const transform = this.transforms.get(tagName);
-                if (!transform) {
-                    throw new Error(`Unrecognized bbcode ${node.tagName}`);
-                }
-                const renderedStartTag = transform.start(node);
-                const renderedEndTag = transform.end?.(node) ?? '';
-                const isInvalidTag = renderedStartTag === false;
-                if (isInvalidTag) {
-                    output += node.ogStartTag;
-                }
-                else {
-                    output += renderedStartTag;
-                }
-                if (!transform.skipChildren || isInvalidTag) {
-                    for (const child of node.children) {
-                        output += stringify(child);
-                    }
-                }
-                if (isInvalidTag) {
-                    output += node.ogEndTag;
-                }
-                else {
-                    output += renderedEndTag;
-                }
-            }
-            else if (nodeIsType(node, 1 /* AstNodeType.TextNode */)) {
-                output += node.str;
-            }
-            else if (nodeIsType(node, 2 /* AstNodeType.LinebreakNode */)) {
-                output += '\n';
-            }
-            else {
-                for (const child of node.children) {
-                    output += stringify(child);
-                }
-            }
-            return output;
-        };
-        return stringify(root);
-    }
-}
-//# sourceMappingURL=Generator.js.map

package/dist/generator/Generator.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"Generator.js","sourceRoot":"","sources":["../../src/generator/Generator.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,UAAU,EAAE,MAAM,yBAAyB,CAAA;AACpD,OAAO,EAAE,cAAc,EAAE,MAAM,gCAAgC,CAAA;AAG/D,MAAM,OAAO,SAAS;IAClB,UAAU,CAAgC;IAE1C,YAAY,UAAU,GAAG,cAAc;QACnC,IAAI,CAAC,UAAU,GAAG,IAAI,GAAG,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC,SAAS,EAAE,EAAE,CAAC,CAAC,SAAS,CAAC,IAAI,EAAE,SAAS,CAAC,CAAC,CAAC,CAAA;IACzF,CAAC;IAED,QAAQ,CAAC,IAAc;QACnB,MAAM,SAAS,GAAG,CAAC,IAAa,EAAU,EAAE;YACxC,IAAI,MAAM,GAAG,EAAE,CAAA;YAEf,IAAI,UAAU,CAAC,IAAI,8BAAsB,EAAE,CAAC;gBACxC,MAAM,OAAO,GAAG,IAAI,CAAC,OAAO,CAAA;gBAC5B,MAAM,SAAS,GAAG,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,OAAO,CAAC,CAAA;gBAC9C,IAAI,CAAC,SAAS,EAAE,CAAC;oBACb,MAAM,IAAI,KAAK,CAAC,uBAAuB,IAAI,CAAC,OAAO,EAAE,CAAC,CAAA;gBAC1D,CAAC;gBAED,MAAM,gBAAgB,GAAG,SAAS,CAAC,KAAK,CAAC,IAAI,CAAC,CAAA;gBAC9C,MAAM,cAAc,GAAG,SAAS,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,IAAI,EAAE,CAAA;gBAClD,MAAM,YAAY,GAAG,gBAAgB,KAAK,KAAK,CAAA;gBAE/C,IAAI,YAAY,EAAE,CAAC;oBACf,MAAM,IAAI,IAAI,CAAC,UAAU,CAAA;gBAC7B,CAAC;qBAAM,CAAC;oBACJ,MAAM,IAAI,gBAAgB,CAAA;gBAC9B,CAAC;gBAED,IAAI,CAAC,SAAS,CAAC,YAAY,IAAI,YAAY,EAAE,CAAC;oBAC1C,KAAK,MAAM,KAAK,IAAI,IAAI,CAAC,QAAQ,EAAE,CAAC;wBAChC,MAAM,IAAI,SAAS,CAAC,KAAK,CAAC,CAAA;oBAC9B,CAAC;gBACL,CAAC;gBAED,IAAI,YAAY,EAAE,CAAC;oBACf,MAAM,IAAI,IAAI,CAAC,QAAQ,CAAA;gBAC3B,CAAC;qBAAM,CAAC;oBACJ,MAAM,IAAI,cAAc,CAAA;gBAC5B,CAAC;YACL,CAAC;iBAAM,IAAI,UAAU,CAAC,IAAI,+BAAuB,EAAE,CAAC;gBAChD,MAAM,IAAI,IAAI,CAAC,GAAG,CAAA;YACtB,CAAC;iBAAM,IAAI,UAAU,CAAC,IAAI,oCAA4B,EAAE,CAAC;gBACrD,MAAM,IAAI,IAAI,CAAA;YAClB,CAAC;iBAAM,CAAC;gBACJ,KAAK,MAAM,KAAK,IAAI,IAAI,CAAC,QAAQ,EAAE,CAAC;oBAChC,MAAM,IAAI,SAAS,CAAC,KAAK,CAAC,CAAA;gBAC9B,CAAC;YACL,CAAC;YAED,OAAO,MAAM,CAAA;QACjB,CAAC,CAAA;QAED,OAAO,SAAS,CAAC,IAAI,CAAC,CAAA;IAC1B,CAAC;CACJ"}

package/dist/generator/transforms/Transform.js

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=Transform.js.map

package/dist/generator/transforms/Transform.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"Transform.js","sourceRoot":"","sources":["../../../src/generator/transforms/Transform.ts"],"names":[],"mappings":""}