redefined Node by constructor function

src/utils/ast.js

@@ -2,14 +2,13 @@
 
 // Function to create a new AST node
 function Node(type, value, left, right) {
-    return {
-      type: type,
-      value: value,
-      left: left,
-      right: right 
-    };
+    this.type = type;
+    this.value = value;
+    this.left = left;
+    this.right = right;
 }
 
+
 const precedence = {
   'imply': 1,
   'or': 2,
@@ -20,7 +19,12 @@ const precedence = {
   'false': 5
 };
 
-function astsToString(nodes){
+function astsToString(nodes) {
+    
+    if (console.log(typeof nodes) instanceof Node) {
+        throw new Error("Invalid input. Only sequent is accepted, not expression.");
+    }
+
     const leftList = nodes[0];
     const rightList = nodes[1];
 
@@ -36,49 +40,56 @@ function astsToString(nodes){
 }
 
 function astToString(node, parentPrecedence = 0) {
-  if (!node) return "";
-
-  let currentPrecedence = precedence[node.type];
-
-  let left = astToString(node.left, currentPrecedence);
-  let right = astToString(node.right, currentPrecedence);
-
-  let result;
-  switch (node.type) {
-      case 'not':
-          result = `!${left}`;
-          break;
-      case 'and':
-          result = `${left}&${right}`;
-          break;
-      case 'or':
-          result = `${left}||${right}`;
-          break;
-      case 'imply':
-          result = `${left}->${right}`;
-          break;
-      case 'symbol':
-          result = node.value;
-          break;
-      case 'true':
-          result = 'true';
-          break;
-      case 'false':
-          result = 'false';
-          break;
-      default:
-          throw new Error(`Unknown node type: ${node.type}`);
-  }
-
-  if (currentPrecedence < parentPrecedence) {
-      result = `(${result})`;
-  }
-
-  return result;
+
+    if (!(console.log(typeof nodes) instanceof Node)) {
+        throw new Error("Invalid input. Only expression is accepted.");
+    }
+
+    if (!node) return "";
+
+    let currentPrecedence = precedence[node.type];
+
+    let left = astToString(node.left, currentPrecedence);
+    let right = astToString(node.right, currentPrecedence);
+
+    let result;
+    switch (node.type) {
+        case 'not':
+            result = `!${left}`;
+            break;
+        case 'and':
+            result = `${left}&${right}`;
+            break;
+        case 'or':
+            result = `${left}||${right}`;
+            break;
+        case 'imply':
+            result = `${left}->${right}`;
+            break;
+        case 'symbol':
+            result = node.value;
+            break;
+        case 'true':
+            result = 'true';
+            break;
+        case 'false':
+            result = 'false';
+            break;
+        default:
+            throw new Error(`Unknown node type: ${node.type}`);
+    }
+
+    if (currentPrecedence < parentPrecedence) {
+        result = `(${result})`;
+    }
+
+    return result;
 }
 
 // nodes are [[ast],[ast]]
 function astsToLateX(nodes) {
+
+    
     const leftList = nodes[0];
     const rightList = nodes[1];
 
@@ -139,13 +150,13 @@ function astToLaTeX(node, parentPrecedence = 0) {
 
   
 var ast = {};
-ast.Not = Node.bind(null, 'not');
-ast.And = Node.bind(null, 'and');
-ast.Or = Node.bind(null, 'or');
-ast.Imply = Node.bind(null, 'imply');
-ast.Symbol = Node.bind(null, 'symbol');
-ast.True = Node.bind(null, 'true');
-ast.False = Node.bind(null, 'false');
+ast.Not = function (value, left, right) { return new Node('not', value, left, right); };
+ast.And = function (value, left, right) { return new Node('and', value, left, right); };
+ast.Or = function (value, left, right) { return new Node('or', value, left, right); };
+ast.Imply = function (value, left, right) { return new Node('imply', value, left, right); };
+ast.Symbol = function (value, left, right) { return new Node('symbol', value, left, right); };
+ast.True = function () { return new Node('true'); };
+ast.False = function () { return new Node('false'); }
 ast.astToString = astToString;
 ast.astToLaTeX = astToLaTeX;
 ast.astsToLateX = astsToLateX;