WIP Bring back discriminated union for MathNode

test/typescript-tests/nodeExtensions.ts

@@ -0,0 +1,52 @@
+import { expectTypeOf } from 'expect-type'
+import {
+  MathNode,
+  BaseNode,
+  MathNodeCommon,
+  ConstantNode,
+  Node,
+  FunctionAssignmentNode,
+} from 'mathjs'
+
+interface MyNode extends BaseNode {
+  type: 'MyNode'
+  a: MathNode
+}
+declare module 'mathjs' {
+  interface MathNodeTypes {
+    MyNode: MyNode
+  }
+}
+
+/*
+MathNode examples
+*/
+{
+  class CustomNode extends Node implements MyNode {
+    a: MathNode
+    type: 'MyNode'
+    constructor(a: MathNode) {
+      super()
+      this.a = a
+    }
+  }
+
+  // Built-in subclass of Node
+  const instance1 = new ConstantNode(2)
+
+  // Custom subclass of node
+  const instance2 = new CustomNode(new ConstantNode(2))
+
+  expectTypeOf(instance1).toMatchTypeOf<MathNode>()
+  expectTypeOf(instance1).toMatchTypeOf<MathNodeCommon>()
+  expectTypeOf(instance1).toMatchTypeOf<ConstantNode>()
+
+  expectTypeOf(instance2).toMatchTypeOf<MathNode>()
+  expectTypeOf(instance2).toMatchTypeOf<MathNodeCommon>()
+  expectTypeOf(instance2).toMatchTypeOf<CustomNode>()
+
+  let instance3: MathNode
+  if (instance3.type === 'FunctionAssignmentNode') {
+    expectTypeOf(instance3).toMatchTypeOf<FunctionAssignmentNode>()
+  }
+}

test/typescript-tests/testTypes.ts

@@ -41,10 +41,9 @@ import {
   SimplifyRule,
   SLUDecomposition,
   SymbolNode,
-  MathNodeCommon,
   Unit,
-  Node,
   isSymbolNode,
+  BaseNode,
 } from 'mathjs'
 import * as assert from 'assert'
 import { expectTypeOf } from 'expect-type'
@@ -1110,7 +1109,7 @@ Transform examples
 
     expectTypeOf(
       math.parse('sqrt(3^2 + 4^2)').transform(myTransform1)
-    ).toMatchTypeOf<OperatorNode<'+', 'add', MathNode[]>>()
+    ).toMatchTypeOf<OperatorNode<'+', 'add', BaseNode[]>>()
 
     assert.deepStrictEqual(
       math.parse('sqrt(3^2 + 4^2)').transform(myTransform1).toString(),
@@ -1122,7 +1121,7 @@ Transform examples
         .parse('sqrt(3^2 + 4^2)')
         .transform(myTransform1)
         .transform(myTransform2)
-    ).toMatchTypeOf<OperatorNode<'-', 'subtract', MathNode[]>>()
+    ).toMatchTypeOf<OperatorNode<'-', 'subtract', BaseNode[]>>()
 
     assert.deepStrictEqual(
       math
@@ -2238,7 +2237,7 @@ Factory Test
   }
   if (math.isOperatorNode(x)) {
     expectTypeOf(x).toMatchTypeOf<
-      OperatorNode<OperatorNodeOp, OperatorNodeFn, MathNode[]>
+      OperatorNode<OperatorNodeOp, OperatorNodeFn, BaseNode[]>
     >()
   }
   if (math.isParenthesisNode(x)) {
@@ -2320,36 +2319,3 @@ Random examples
     MathJsChain<number[]>
   >()
 }
-
-/*
-MathNode examples
-*/
-{
-  class CustomNode extends Node {
-    a: MathNode
-    constructor(a: MathNode) {
-      super()
-      this.a = a
-    }
-  }
-
-  // Basic node
-  const instance1 = new Node()
-
-  // Built-in subclass of Node
-  const instance2 = new ConstantNode(2)
-
-  // Custom subclass of node
-  const instance3 = new CustomNode(new ConstantNode(2))
-
-  expectTypeOf(instance1).toMatchTypeOf<MathNode>()
-  expectTypeOf(instance1).toMatchTypeOf<MathNodeCommon>()
-
-  expectTypeOf(instance2).toMatchTypeOf<MathNode>()
-  expectTypeOf(instance2).toMatchTypeOf<MathNodeCommon>()
-  expectTypeOf(instance2).toMatchTypeOf<ConstantNode>()
-
-  expectTypeOf(instance3).toMatchTypeOf<MathNode>()
-  expectTypeOf(instance3).toMatchTypeOf<MathNodeCommon>()
-  expectTypeOf(instance3).toMatchTypeOf<CustomNode>()
-}