graph-typed 1.50.8 → 1.51.0

package/dist/data-structures/binary-tree/tree-multi-map.d.ts

@@ -5,21 +5,24 @@
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import type { BinaryTreeDeleteResult, BSTNKeyOrNode, BTNCallback, KeyOrNodeOrEntry, TreeMultiMapNested, TreeMultiMapNodeNested, TreeMultiMapOptions } from '../../types';
+import type { BinaryTreeDeleteResult, BSTNKeyOrNode, BTNCallback, IterationType, KeyOrNodeOrEntry, TreeMultiMapNested, TreeMultiMapNodeNested, TreeMultiMapOptions } from '../../types';
+import { RBTNColor } from '../../types';
 import { IBinaryTree } from '../../interfaces';
 import { RedBlackTree, RedBlackTreeNode } from './rb-tree';
 export declare class TreeMultiMapNode<K = any, V = any, NODE extends TreeMultiMapNode<K, V, NODE> = TreeMultiMapNodeNested<K, V>> extends RedBlackTreeNode<K, V, NODE> {
     /**
-     * The constructor function initializes an instance of a class with a key, value, and count.
-     * @param {K} key - The key parameter is of type K, which represents the type of the key for the
-     * constructor. It is required and must be provided when creating an instance of the class.
-     * @param {V} [value] - The `value` parameter is an optional parameter of type `V`. It represents the
-     * value associated with the key in the constructor. If no value is provided, it will be `undefined`.
-     * @param [count=1] - The "count" parameter is an optional parameter that specifies the number of
-     * times the key-value pair should be repeated. If no value is provided for "count", it defaults to
-     * 1.
-     */
-    constructor(key: K, value?: V, count?: number);
+     * The constructor function initializes a Red-Black Tree node with a key, value, count, and color.
+     * @param {K} key - The key parameter represents the key of the node in the Red-Black Tree. It is
+     * used to identify and locate the node within the tree.
+     * @param {V} [value] - The `value` parameter is an optional parameter that represents the value
+     * associated with the key in the Red-Black Tree node. It is not required and can be omitted when
+     * creating a new node.
+     * @param [count=1] - The `count` parameter represents the number of occurrences of a particular key
+     * in the Red-Black Tree. It is an optional parameter with a default value of 1.
+     * @param {RBTNColor} [color=BLACK] - The `color` parameter is used to specify the color of the node
+     * in a Red-Black Tree. It is optional and has a default value of `'BLACK'`.
+     */
+    constructor(key: K, value?: V, count?: number, color?: RBTNColor);
     protected _count: number;
     /**
      * The function returns the value of the private variable _count.
@@ -50,19 +53,34 @@ export declare class TreeMultiMap<K = any, V = any, NODE extends TreeMultiMapNod
      * @returns the sum of the count property of all nodes in the tree.
      */
     get count(): number;
-    getMutableCount(): number;
     /**
-     * The function creates a new TreeMultiMapNode object with the specified key, value, and count.
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
+     */
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
+     *
+     * The function calculates the sum of the count property of all nodes in a tree using depth-first
+     * search.
+     * @returns the sum of the count property of all nodes in the tree.
+     */
+    getComputedCount(): number;
+    /**
+     * The function creates a new TreeMultiMapNode with the specified key, value, color, and count.
      * @param {K} key - The key parameter represents the key of the node being created. It is of type K,
-     * which is a generic type that can be replaced with any specific type when using the function.
-     * @param {V} [value] - The `value` parameter is an optional parameter that represents the value
-     * associated with the key in the node. It is of type `V`, which can be any data type.
-     * @param {number} [count] - The `count` parameter represents the number of occurrences of a
-     * key-value pair in the TreeMultiMap. It is an optional parameter, so if it is not provided, it will
-     * default to 1.
-     * @returns a new instance of the TreeMultiMapNode class, casted as NODE.
+     * which is a generic type representing the key type of the node.
+     * @param {V} [value] - The `value` parameter represents the value associated with the key in the
+     * node. It is an optional parameter, which means it can be omitted when calling the `createNode`
+     * function. If provided, it should be of type `V`.
+     * @param {RBTNColor} [color=BLACK] - The color parameter is used to specify the color of the node in
+     * a Red-Black Tree. It can have two possible values: 'RED' or 'BLACK'. The default value is 'BLACK'.
+     * @param {number} [count] - The `count` parameter represents the number of occurrences of a key in
+     * the tree. It is an optional parameter and is used to keep track of the number of values associated
+     * with a key in the tree.
+     * @returns A new instance of the TreeMultiMapNode class is being returned.
      */
-    createNode(key: K, value?: V, count?: number): NODE;
+    createNode(key: K, value?: V, color?: RBTNColor, count?: number): NODE;
     /**
      * The function creates a new instance of a TreeMultiMap with the specified options and returns it.
      * @param [options] - The `options` parameter is an optional object that contains additional
@@ -163,7 +181,7 @@ export declare class TreeMultiMap<K = any, V = any, NODE extends TreeMultiMapNod
      * values:
      * @returns a boolean value.
      */
-    perfectlyBalance(iterationType?: import("../../types").IterationType): boolean;
+    perfectlyBalance(iterationType?: IterationType): boolean;
     /**
      * Time complexity: O(n)
      * Space complexity: O(n)

package/dist/data-structures/binary-tree/tree-multi-map.js

@@ -1,21 +1,22 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TreeMultiMap = exports.TreeMultiMapNode = void 0;
-const types_1 = require("../../types");
 const rb_tree_1 = require("./rb-tree");
 class TreeMultiMapNode extends rb_tree_1.RedBlackTreeNode {
     /**
-     * The constructor function initializes an instance of a class with a key, value, and count.
-     * @param {K} key - The key parameter is of type K, which represents the type of the key for the
-     * constructor. It is required and must be provided when creating an instance of the class.
-     * @param {V} [value] - The `value` parameter is an optional parameter of type `V`. It represents the
-     * value associated with the key in the constructor. If no value is provided, it will be `undefined`.
-     * @param [count=1] - The "count" parameter is an optional parameter that specifies the number of
-     * times the key-value pair should be repeated. If no value is provided for "count", it defaults to
-     * 1.
+     * The constructor function initializes a Red-Black Tree node with a key, value, count, and color.
+     * @param {K} key - The key parameter represents the key of the node in the Red-Black Tree. It is
+     * used to identify and locate the node within the tree.
+     * @param {V} [value] - The `value` parameter is an optional parameter that represents the value
+     * associated with the key in the Red-Black Tree node. It is not required and can be omitted when
+     * creating a new node.
+     * @param [count=1] - The `count` parameter represents the number of occurrences of a particular key
+     * in the Red-Black Tree. It is an optional parameter with a default value of 1.
+     * @param {RBTNColor} [color=BLACK] - The `color` parameter is used to specify the color of the node
+     * in a Red-Black Tree. It is optional and has a default value of `'BLACK'`.
      */
-    constructor(key, value, count = 1) {
-        super(key, value);
+    constructor(key, value, count = 1, color = 'BLACK') {
+        super(key, value, color);
         this._count = 1;
         this.count = count;
     }
@@ -60,24 +61,39 @@ class TreeMultiMap extends rb_tree_1.RedBlackTree {
     get count() {
         return this._count;
     }
-    getMutableCount() {
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
+     */
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
+     *
+     * The function calculates the sum of the count property of all nodes in a tree using depth-first
+     * search.
+     * @returns the sum of the count property of all nodes in the tree.
+     */
+    getComputedCount() {
         let sum = 0;
         this.dfs(node => (sum += node.count));
         return sum;
     }
     /**
-     * The function creates a new TreeMultiMapNode object with the specified key, value, and count.
+     * The function creates a new TreeMultiMapNode with the specified key, value, color, and count.
      * @param {K} key - The key parameter represents the key of the node being created. It is of type K,
-     * which is a generic type that can be replaced with any specific type when using the function.
-     * @param {V} [value] - The `value` parameter is an optional parameter that represents the value
-     * associated with the key in the node. It is of type `V`, which can be any data type.
-     * @param {number} [count] - The `count` parameter represents the number of occurrences of a
-     * key-value pair in the TreeMultiMap. It is an optional parameter, so if it is not provided, it will
-     * default to 1.
-     * @returns a new instance of the TreeMultiMapNode class, casted as NODE.
+     * which is a generic type representing the key type of the node.
+     * @param {V} [value] - The `value` parameter represents the value associated with the key in the
+     * node. It is an optional parameter, which means it can be omitted when calling the `createNode`
+     * function. If provided, it should be of type `V`.
+     * @param {RBTNColor} [color=BLACK] - The color parameter is used to specify the color of the node in
+     * a Red-Black Tree. It can have two possible values: 'RED' or 'BLACK'. The default value is 'BLACK'.
+     * @param {number} [count] - The `count` parameter represents the number of occurrences of a key in
+     * the tree. It is an optional parameter and is used to keep track of the number of values associated
+     * with a key in the tree.
+     * @returns A new instance of the TreeMultiMapNode class is being returned.
      */
-    createNode(key, value, count) {
-        return new TreeMultiMapNode(key, value, count);
+    createNode(key, value, color = 'BLACK', count) {
+        return new TreeMultiMapNode(key, value, count, color);
     }
     /**
      * The function creates a new instance of a TreeMultiMap with the specified options and returns it.
@@ -115,11 +131,11 @@ class TreeMultiMap extends rb_tree_1.RedBlackTree {
                 return;
             }
             else {
-                node = this.createNode(key, value, count);
+                node = this.createNode(key, value, 'BLACK', count);
             }
         }
         else if (!this.isNode(keyOrNodeOrEntry)) {
-            node = this.createNode(keyOrNodeOrEntry, value, count);
+            node = this.createNode(keyOrNodeOrEntry, value, 'BLACK', count);
         }
         else {
             return;
@@ -271,7 +287,7 @@ class TreeMultiMap extends rb_tree_1.RedBlackTree {
         }
         this._size--;
         // If the original color was black, fix the tree
-        if (originalColor === types_1.RBTNColor.BLACK) {
+        if (originalColor === 'BLACK') {
             this._deleteFixup(replacementNode);
         }
         results.push({ deleted: nodeToDelete, needBalanced: undefined });
@@ -308,7 +324,7 @@ class TreeMultiMap extends rb_tree_1.RedBlackTree {
      * @returns a boolean value.
      */
     perfectlyBalance(iterationType = this.iterationType) {
-        const sorted = this.dfs(node => node, 'in'), n = sorted.length;
+        const sorted = this.dfs(node => node, 'IN'), n = sorted.length;
         if (sorted.length < 1)
             return false;
         this.clear();
@@ -375,7 +391,7 @@ class TreeMultiMap extends rb_tree_1.RedBlackTree {
         destNode = this.ensureNode(destNode);
         if (srcNode && destNode) {
             const { key, value, count, color } = destNode;
-            const tempNode = this.createNode(key, value, count);
+            const tempNode = this.createNode(key, value, color, count);
             if (tempNode) {
                 tempNode.color = color;
                 destNode.key = srcNode.key;

package/dist/data-structures/heap/heap.d.ts

@@ -159,7 +159,7 @@ export declare class Heap<E = any> extends IterableElementBase<E> {
      * Space Complexity: O(log n)
      *
      * Depth-first search (DFS) method, different traversal orders can be selected。
-     * @param order - Traverse order parameter: 'in' (in-order), 'pre' (pre-order) or 'post' (post-order).
+     * @param order - Traverse order parameter: 'IN' (in-order), 'PRE' (pre-order) or 'POST' (post-order).
      * @returns An array containing elements traversed in the specified order.
      */
     dfs(order?: DFSOrderPattern): E[];

package/dist/data-structures/heap/heap.js

@@ -229,26 +229,26 @@ class Heap extends base_1.IterableElementBase {
      * Space Complexity: O(log n)
      *
      * Depth-first search (DFS) method, different traversal orders can be selected。
-     * @param order - Traverse order parameter: 'in' (in-order), 'pre' (pre-order) or 'post' (post-order).
+     * @param order - Traverse order parameter: 'IN' (in-order), 'PRE' (pre-order) or 'POST' (post-order).
      * @returns An array containing elements traversed in the specified order.
      */
-    dfs(order = 'pre') {
+    dfs(order = 'PRE') {
         const result = [];
         // Auxiliary recursive function, traverses the binary heap according to the traversal order
         const _dfs = (index) => {
             const left = 2 * index + 1, right = left + 1;
             if (index < this.size) {
-                if (order === 'in') {
+                if (order === 'IN') {
                     _dfs(left);
                     result.push(this.elements[index]);
                     _dfs(right);
                 }
-                else if (order === 'pre') {
+                else if (order === 'PRE') {
                     result.push(this.elements[index]);
                     _dfs(left);
                     _dfs(right);
                 }
-                else if (order === 'post') {
+                else if (order === 'POST') {
                     _dfs(left);
                     _dfs(right);
                     result.push(this.elements[index]);

package/dist/types/common.d.ts

@@ -9,7 +9,7 @@ export type CP = 'LT' | 'EQ' | 'GT';
 export type IterationType = 'ITERATIVE' | 'RECURSIVE';
 export type FamilyPosition = 'ROOT' | 'LEFT' | 'RIGHT' | 'ROOT_LEFT' | 'ROOT_RIGHT' | 'ISOLATED' | 'MAL_NODE';
 export type Comparator<K> = (a: K, b: K) => number;
-export type DFSOrderPattern = 'pre' | 'in' | 'post';
+export type DFSOrderPattern = 'PRE' | 'IN' | 'POST';
 export type NodeDisplayLayout = [string[], number, number, number];
 export type BTNCallback<N, D = any> = (node: N) => D;
 export interface IterableWithSize<T> extends Iterable<T> {

package/dist/types/data-structures/binary-tree/rb-tree.d.ts

@@ -1,9 +1,6 @@
 import { RedBlackTree, RedBlackTreeNode } from '../../../data-structures';
 import type { BSTOptions } from "./bst";
-export declare enum RBTNColor {
-    RED = 1,
-    BLACK = 0
-}
+export type RBTNColor = 'RED' | 'BLACK';
 export type RedBlackTreeNodeNested<K, V> = RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>;
 export type RedBlackTreeNested<K, V, N extends RedBlackTreeNode<K, V, N>> = RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>;
 export type RBTreeOptions<K> = Omit<BSTOptions<K>, 'variant'> & {};

package/dist/types/data-structures/binary-tree/rb-tree.js

@@ -1,8 +1,2 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RBTNColor = void 0;
-var RBTNColor;
-(function (RBTNColor) {
-    RBTNColor[RBTNColor["RED"] = 1] = "RED";
-    RBTNColor[RBTNColor["BLACK"] = 0] = "BLACK";
-})(RBTNColor = exports.RBTNColor || (exports.RBTNColor = {}));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "graph-typed",
-  "version": "1.50.8",
+  "version": "1.51.0",
   "description": "Graph. Javascript & Typescript Data Structure.",
   "main": "dist/index.js",
   "scripts": {
@@ -136,6 +136,6 @@
     "typescript": "^4.9.5"
   },
   "dependencies": {
-    "data-structure-typed": "^1.50.8"
+    "data-structure-typed": "^1.51.0"
   }
 }

package/src/data-structures/binary-tree/avl-tree-multi-map.ts

@@ -12,6 +12,7 @@ import type {
   BinaryTreeDeleteResult,
   BSTNKeyOrNode,
   BTNCallback,
+  IterationType,
   KeyOrNodeOrEntry
 } from '../../types';
 import { IBinaryTree } from '../../interfaces';
@@ -85,7 +86,20 @@ export class AVLTreeMultiMap<
     return this._count;
   }
 
-  getMutableCount(): number {
+  /**
+   * Time Complexity: O(n)
+   * Space Complexity: O(1)
+   */
+
+  /**
+   * Time Complexity: O(n)
+   * Space Complexity: O(1)
+   *
+   * The function calculates the sum of the count property of all nodes in a tree using depth-first
+   * search.
+   * @returns the sum of the count property of all nodes in the tree.
+   */
+  getComputedCount(): number {
     let sum = 0;
     this.dfs(node => (sum += node.count));
     return sum;
@@ -316,8 +330,8 @@ export class AVLTreeMultiMap<
    * values:
    * @returns a boolean value.
    */
-  override perfectlyBalance(iterationType = this.iterationType): boolean {
-    const sorted = this.dfs(node => node, 'in'),
+  override perfectlyBalance(iterationType: IterationType = this.iterationType): boolean {
+    const sorted = this.dfs(node => node, 'IN'),
       n = sorted.length;
     if (sorted.length < 1) return false;
 

package/src/data-structures/binary-tree/binary-tree.ts

@@ -264,7 +264,10 @@ export class BinaryTree<
    * @returns either the node corresponding to the given key if it is a valid node key, or the key
    * itself if it is not a valid node key.
    */
-  ensureNode(keyOrNodeOrEntry: KeyOrNodeOrEntry<K, V, NODE>, iterationType = 'ITERATIVE'): NODE | null | undefined {
+  ensureNode(
+    keyOrNodeOrEntry: KeyOrNodeOrEntry<K, V, NODE>,
+    iterationType: IterationType = 'ITERATIVE'
+  ): NODE | null | undefined {
     let res: NODE | null | undefined;
     if (this.isRealNode(keyOrNodeOrEntry)) {
       res = keyOrNodeOrEntry;
@@ -594,7 +597,7 @@ export class BinaryTree<
     callback: C = this._defaultOneParamCallback as C,
     onlyOne = false,
     beginRoot: KeyOrNodeOrEntry<K, V, NODE> = this.root,
-    iterationType = this.iterationType
+    iterationType: IterationType = this.iterationType
   ): NODE[] {
     if ((!callback || callback === this._defaultOneParamCallback) && (identifier as any) instanceof BinaryTreeNode)
       callback = (node => node) as C;
@@ -684,7 +687,7 @@ export class BinaryTree<
     identifier: ReturnType<C> | null | undefined,
     callback: C = this._defaultOneParamCallback as C,
     beginRoot: KeyOrNodeOrEntry<K, V, NODE> = this.root,
-    iterationType = this.iterationType
+    iterationType: IterationType = this.iterationType
   ): NODE | null | undefined {
     if ((!callback || callback === this._defaultOneParamCallback) && (identifier as any) instanceof BinaryTreeNode)
       callback = (node => node) as C;
@@ -711,7 +714,7 @@ export class BinaryTree<
    * @returns The function `getNodeByKey` returns a node (`NODE`) if a node with the specified key is
    * found in the binary tree. If no node is found, it returns `undefined`.
    */
-  getNodeByKey(key: K, iterationType = 'ITERATIVE'): NODE | undefined {
+  getNodeByKey(key: K, iterationType: IterationType = 'ITERATIVE'): NODE | undefined {
     if (!this.root) return undefined;
     if (iterationType === 'RECURSIVE') {
       const _dfs = (cur: NODE): NODE | undefined => {
@@ -788,7 +791,7 @@ export class BinaryTree<
     identifier: ReturnType<C> | null | undefined,
     callback: C = this._defaultOneParamCallback as C,
     beginRoot: KeyOrNodeOrEntry<K, V, NODE> = this.root,
-    iterationType = this.iterationType
+    iterationType: IterationType = this.iterationType
   ): V | undefined {
     if ((!callback || callback === this._defaultOneParamCallback) && (identifier as any) instanceof BinaryTreeNode)
       callback = (node => node) as C;
@@ -847,7 +850,7 @@ export class BinaryTree<
     identifier: ReturnType<C> | null | undefined,
     callback: C = this._defaultOneParamCallback as C,
     beginRoot: KeyOrNodeOrEntry<K, V, NODE> = this.root,
-    iterationType = this.iterationType
+    iterationType: IterationType = this.iterationType
   ): boolean {
     if ((!callback || callback === this._defaultOneParamCallback) && (identifier as any) instanceof BinaryTreeNode)
       callback = (node => node) as C;
@@ -924,7 +927,10 @@ export class BinaryTree<
    * possible values:
    * @returns a boolean value.
    */
-  isBST(beginRoot: KeyOrNodeOrEntry<K, V, NODE> = this.root, iterationType = this.iterationType): boolean {
+  isBST(
+    beginRoot: KeyOrNodeOrEntry<K, V, NODE> = this.root,
+    iterationType: IterationType = this.iterationType
+  ): boolean {
     // TODO there is a bug
     beginRoot = this.ensureNode(beginRoot);
     if (!beginRoot) return true;
@@ -1016,7 +1022,10 @@ export class BinaryTree<
    * values:
    * @returns the height of the binary tree.
    */
-  getHeight(beginRoot: KeyOrNodeOrEntry<K, V, NODE> = this.root, iterationType = this.iterationType): number {
+  getHeight(
+    beginRoot: KeyOrNodeOrEntry<K, V, NODE> = this.root,
+    iterationType: IterationType = this.iterationType
+  ): number {
     beginRoot = this.ensureNode(beginRoot);
     if (!this.isRealNode(beginRoot)) return -1;
 
@@ -1064,7 +1073,10 @@ export class BinaryTree<
    * to calculate the minimum height of a binary tree. It can have two possible values:
    * @returns The function `getMinHeight` returns the minimum height of a binary tree.
    */
-  getMinHeight(beginRoot: KeyOrNodeOrEntry<K, V, NODE> = this.root, iterationType = this.iterationType): number {
+  getMinHeight(
+    beginRoot: KeyOrNodeOrEntry<K, V, NODE> = this.root,
+    iterationType: IterationType = this.iterationType
+  ): number {
     beginRoot = this.ensureNode(beginRoot);
     if (!beginRoot) return -1;
 
@@ -1164,7 +1176,7 @@ export class BinaryTree<
    */
   getLeftMost(
     beginRoot: KeyOrNodeOrEntry<K, V, NODE> = this.root,
-    iterationType = this.iterationType
+    iterationType: IterationType = this.iterationType
   ): NODE | null | undefined {
     if (this.isNIL(beginRoot)) return beginRoot as NODE;
     beginRoot = this.ensureNode(beginRoot);
@@ -1211,7 +1223,7 @@ export class BinaryTree<
    */
   getRightMost(
     beginRoot: KeyOrNodeOrEntry<K, V, NODE> = this.root,
-    iterationType = this.iterationType
+    iterationType: IterationType = this.iterationType
   ): NODE | null | undefined {
     if (this.isNIL(beginRoot)) return beginRoot as NODE;
     // TODO support get right most by passing key in
@@ -1340,7 +1352,7 @@ export class BinaryTree<
    */
   dfs<C extends BTNCallback<NODE | null | undefined>>(
     callback: C = this._defaultOneParamCallback as C,
-    pattern: DFSOrderPattern = 'in',
+    pattern: DFSOrderPattern = 'IN',
     beginRoot: KeyOrNodeOrEntry<K, V, NODE> = this.root,
     iterationType: IterationType = 'ITERATIVE',
     includeNull = false
@@ -1351,7 +1363,7 @@ export class BinaryTree<
     if (iterationType === 'RECURSIVE') {
       const _traverse = (node: NODE | null | undefined) => {
         switch (pattern) {
-          case 'in':
+          case 'IN':
             if (includeNull) {
               if (this.isRealNode(node) && this.isNodeOrNull(node.left)) _traverse(node.left);
               this.isNodeOrNull(node) && ans.push(callback(node));
@@ -1362,7 +1374,7 @@ export class BinaryTree<
               if (this.isRealNode(node) && this.isRealNode(node.right)) _traverse(node.right);
             }
             break;
-          case 'pre':
+          case 'PRE':
             if (includeNull) {
               this.isNodeOrNull(node) && ans.push(callback(node));
               if (this.isRealNode(node) && this.isNodeOrNull(node.left)) _traverse(node.left);
@@ -1373,7 +1385,7 @@ export class BinaryTree<
               if (this.isRealNode(node) && this.isRealNode(node.right)) _traverse(node.right);
             }
             break;
-          case 'post':
+          case 'POST':
             if (includeNull) {
               if (this.isRealNode(node) && this.isNodeOrNull(node.left)) _traverse(node.left);
               if (this.isRealNode(node) && this.isNodeOrNull(node.right)) _traverse(node.right);
@@ -1405,17 +1417,17 @@ export class BinaryTree<
           ans.push(callback(cur.node));
         } else {
           switch (pattern) {
-            case 'in':
+            case 'IN':
               cur.node && stack.push({ opt: 0, node: cur.node.right });
               stack.push({ opt: 1, node: cur.node });
               cur.node && stack.push({ opt: 0, node: cur.node.left });
               break;
-            case 'pre':
+            case 'PRE':
               cur.node && stack.push({ opt: 0, node: cur.node.right });
               cur.node && stack.push({ opt: 0, node: cur.node.left });
               stack.push({ opt: 1, node: cur.node });
               break;
-            case 'post':
+            case 'POST':
               stack.push({ opt: 1, node: cur.node });
               cur.node && stack.push({ opt: 0, node: cur.node.right });
               cur.node && stack.push({ opt: 0, node: cur.node.left });
@@ -1476,7 +1488,7 @@ export class BinaryTree<
   bfs<C extends BTNCallback<NODE | null>>(
     callback: C = this._defaultOneParamCallback as C,
     beginRoot: KeyOrNodeOrEntry<K, V, NODE> = this.root,
-    iterationType = this.iterationType,
+    iterationType: IterationType = this.iterationType,
     includeNull = false
   ): ReturnType<C>[] {
     beginRoot = this.ensureNode(beginRoot);
@@ -1570,7 +1582,7 @@ export class BinaryTree<
   listLevels<C extends BTNCallback<NODE | null>>(
     callback: C = this._defaultOneParamCallback as C,
     beginRoot: KeyOrNodeOrEntry<K, V, NODE> = this.root,
-    iterationType = this.iterationType,
+    iterationType: IterationType = this.iterationType,
     includeNull = false
   ): ReturnType<C>[][] {
     beginRoot = this.ensureNode(beginRoot);
@@ -1640,7 +1652,7 @@ export class BinaryTree<
    */
   morris<C extends BTNCallback<NODE>>(
     callback: C = this._defaultOneParamCallback as C,
-    pattern: DFSOrderPattern = 'in',
+    pattern: DFSOrderPattern = 'IN',
     beginRoot: KeyOrNodeOrEntry<K, V, NODE> = this.root
   ): ReturnType<C>[] {
     beginRoot = this.ensureNode(beginRoot);
@@ -1669,7 +1681,7 @@ export class BinaryTree<
       _reverseEdge(tail);
     };
     switch (pattern) {
-      case 'in':
+      case 'IN':
         while (cur) {
           if (cur.left) {
             const predecessor = this.getPredecessor(cur);
@@ -1685,7 +1697,7 @@ export class BinaryTree<
           cur = cur.right;
         }
         break;
-      case 'pre':
+      case 'PRE':
         while (cur) {
           if (cur.left) {
             const predecessor = this.getPredecessor(cur);
@@ -1703,7 +1715,7 @@ export class BinaryTree<
           cur = cur.right;
         }
         break;
-      case 'post':
+      case 'POST':
         while (cur) {
           if (cur.left) {
             const predecessor = this.getPredecessor(cur);