@flomsstaar/expression-tree 0.1.0 → 0.1.2

package/src/expression_tree.ts

@@ -1,19 +0,0 @@
-import { ExpressionCutter } from './expression_cutter.js'
-import { ExpressionParser } from './expression_parser.js'
-import { ExpressionEvaluator } from './expression_evaluator.js'
-
-export class ExpressionTree {
-  constructor(
-    protected cutter = new ExpressionCutter(),
-    protected parser = new ExpressionParser(),
-    protected evaluator = new ExpressionEvaluator()
-  ) {}
-
-  evaluate(expression: string): number {
-    const cutExpression = this.cutter.cut(expression)
-
-    const baseNode = this.parser.parse(cutExpression)
-
-    return this.evaluator.evaluate(baseNode)
-  }
-}

package/src/models/base_node.ts

@@ -1,5 +0,0 @@
-import type { NodeType } from '../enums/node_type.js'
-
-export abstract class BaseNode {
-  protected constructor(public readonly type: NodeType) {}
-}

package/src/models/binary_node.ts

@@ -1,13 +0,0 @@
-import { BaseNode } from './base_node.js'
-import { BinaryNodeOperator } from '../enums/binary_node_operator.js'
-import { NodeType } from '../enums/node_type.js'
-
-export class BinaryNode extends BaseNode {
-  constructor(
-    public operator: BinaryNodeOperator,
-    public left: BaseNode,
-    public right: BaseNode
-  ) {
-    super(NodeType.BINARY)
-  }
-}

package/src/models/number_node.ts

@@ -1,12 +0,0 @@
-import { BaseNode } from './base_node.js'
-import { NodeType } from '../enums/node_type.js'
-
-export class NumberNode extends BaseNode {
-  constructor(public readonly value: number) {
-    super(NodeType.NUMBER)
-  }
-
-  toString(): string {
-    return this.value.toString()
-  }
-}

package/src/models/unary_node.ts

@@ -1,12 +0,0 @@
-import { BaseNode } from './base_node.js'
-import type { UnaryNodeOperator } from '../enums/unary_node_operator.js'
-import { NodeType } from '../enums/node_type.js'
-
-export class UnaryNode extends BaseNode {
-  constructor(
-    public operator: UnaryNodeOperator,
-    public value: BaseNode
-  ) {
-    super(NodeType.UNARY)
-  }
-}

package/src/render_expression.ts

@@ -1,57 +0,0 @@
-import type { BaseNode } from './models/base_node.js'
-import { NumberNode } from './models/number_node.js'
-import { BinaryNode } from './models/binary_node.js'
-import { BinaryNodeOperator } from './enums/binary_node_operator.js'
-import { UnknownBinaryOperatorError } from './errors/unknown_binary_operator_error.js'
-import { UnaryNode } from './models/unary_node.js'
-import { UnaryNodeOperator } from './enums/unary_node_operator.js'
-import { UnknownUnaryOperatorError } from './errors/unknown_unary_operator_error.js'
-import { UnknownNodeTypeError } from './errors/unknown_node_type_error.js'
-
-export function renderExpression(node: BaseNode): string {
-  if (node instanceof BinaryNode) {
-    const leftNode = renderExpression(node.left)
-    const rightNode = renderExpression(node.right)
-    const operator = {
-      [BinaryNodeOperator.SUM]: '+',
-      [BinaryNodeOperator.SUBTRACT]: '-',
-      [BinaryNodeOperator.MULTIPLY]: '*',
-      [BinaryNodeOperator.DIVIDE]: '/',
-      [BinaryNodeOperator.POWER]: '^',
-    }[node.operator]
-
-    if (!operator) {
-      throw new UnknownBinaryOperatorError(node.operator)
-    }
-
-    return `${leftNode} ${operator} ${rightNode}`
-  } else if (node instanceof UnaryNode) {
-    switch (node.operator) {
-      case UnaryNodeOperator.NEGATE: {
-        if (node.value instanceof NumberNode && node.value.value === 0) {
-          return '0'
-        } else if (node.value instanceof BinaryNode) {
-          const valueNode = renderExpression(node.value)
-          return `-(${valueNode})`
-        }
-
-        const valueNode = renderExpression(node.value)
-        return `-${valueNode}`
-      }
-      case UnaryNodeOperator.ABSOLUTE: {
-        const valueNode = renderExpression(node.value)
-        return `abs(${valueNode})`
-      }
-      case UnaryNodeOperator.SQUARE_ROOT: {
-        const valueNode = renderExpression(node.value)
-        return `sqrt(${valueNode})`
-      }
-      default:
-        throw new UnknownUnaryOperatorError(node.operator)
-    }
-  } else if (node instanceof NumberNode) {
-    return node.toString()
-  } else {
-    throw new UnknownNodeTypeError(node.type)
-  }
-}