added linkSequentNode functions and tests. added isSequentNode,...

added linkSequentNode functions and tests. added isSequentNode, generateProofTreeHTML for the proof tree rendering

src/utils/sequentAst.js

 // Define sequentNode constructor function
-function sequentNode(value, left, right) {
-    this.value = value;
-    this.left = left;
-    this.right = right;
+// top is a list of string, for children nodes
+// bottom is a string, for the current node
+function sequentNode(bottom, rule = "", tops=[]) {
+    this.rule = rule;
+    this.bottom = bottom;
+    this.tops = tops;
+}
+
+function addRule(node, rule) {
+    node.rule = rule;
+}
+
+function generateProofTreeHTML(node) {
+    if (!node) return '';
+
+    // Generate the HTML for the current node
+    let html = '<div class="node">';
+
+    if (node.rule) {
+        html += '<div class="tops">';
+        // Recursively process prerequisite nodes
+        node.tops.forEach(childNode => {
+            html += generateProofTreeHTML(childNode);
+        });
+        html += '</div>';
+        html += `<div class="bar"><div class="rule">\\(${node.rule}\\)</div></div>`;
+    }
+
+    html += `<div class="bottom"><span class="math">\\(${node.bottom}\\)</span></div>`;
+    html += '</div>';
+
+    return html;
 }
 
 // Define isSequentNode function to check if an object is an instance of sequentNode
 function isSequentNode(obj) {
     return obj instanceof sequentNode &&
-        'value' in obj &&
-        'left' in obj &&
-        'right' in obj;
+        typeof obj.rule === 'string' &&
+        typeof obj.bottom === 'string' &&
+        Array.isArray(obj.tops) &&
+        obj.tops.every(top => top instanceof sequentNode);
 }
 
 // Define linkSequentNode function to link a new node to an existing node, prioritizing the left side
@@ -23,18 +52,19 @@ function linkSequentNode(existingNode, newNode) {
     }
 
     // Prioritize linking to the left
-    if (!existingNode.left) {
-        existingNode.left = newNode;
-    } else if (!existingNode.right) {
-        existingNode.right = newNode;
+    if (existingNode.tops.length < 2) {
+        existingNode.tops.push(newNode);
     } else {
-        // If both left and right nodes are occupied, recursively try to link to the left child node
-        linkSequentNode(existingNode.left, newNode);
+        throw new Error('Addition failed, this node is already full');
     }
+
+    return existingNode;
 }
 
 module.exports = {
     sequentNode,
     isSequentNode,
-    linkSequentNode
+    linkSequentNode,
+    generateProofTreeHTML,
+    addRule
 };
\ No newline at end of file

tests/unit/ast.test.js → tests/unit/ExpAst.test.js

 const { parse } = require("../../src/utils/parser.js");
-const ast = require('../../src/utils/expAst.js/index.js');
+const ast = require('../../src/utils/expAst.js');
 
-// isNode test
+// isExpNode test
 test('isNode could work correctly for node', () => {
     const input = ast.Symbol("symbol", "A", null, null);
-    const output = ast.isNode(input);
+    const output = ast.isExpNode(input);
     expect(output).toEqual(true);
 });
 

tests/unit/sequentAst.test.js

+
+const { sequentNode, linkSequentNode } = require("../../src/utils/sequentAst.js");
+
+// linkSequentNode test
+test('linkSequentNode could work correctly for node', () => {
+    const inputA = new sequentNode("A");
+    const inputB = new sequentNode("B");
+    const output = linkSequentNode(inputA, inputB);
+
+    const expected = new sequentNode("A", "", [inputB]);
+    expect(output).toEqual(expected);
+});
+
+test('linkSequentNode could work correctly for node', () => {
+    const inputA = new sequentNode("A");
+    const inputB = new sequentNode("B");
+    const output = linkSequentNode(inputA, inputB);
+    const output1 = linkSequentNode(output, inputB);
+    expect(output1).toEqual(new sequentNode("A", "", [inputB, inputB]));
+});
+
+test('linkSequentNode could report error when adding nodes on a full node', () => {
+    const inputA = new sequentNode("A");
+    const inputB = new sequentNode("B");
+    const output = linkSequentNode(inputA, inputB);
+    const output1 = linkSequentNode(output, inputB);
+    expect(() => linkSequentNode(output1, inputB)).toThrow('Addition failed, this node is already full');
+
+});