bst-typed 1.53.0 → 1.53.1

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

@@ -86,7 +86,7 @@ class AVLTreeMultiMap extends avl_tree_1.AVLTree {
      * @returns a new instance of the AVLTreeMultiMapNode class, casted as NODE.
      */
     createNode(key, value, count) {
-        return new AVLTreeMultiMapNode(key, value, count);
+        return new AVLTreeMultiMapNode(key, this._isMapMode ? undefined : value, count);
     }
     /**
      * The function creates a new AVLTreeMultiMap object with the specified options and returns it.

package/dist/data-structures/binary-tree/avl-tree.js

@@ -75,7 +75,7 @@ class AVLTree extends bst_1.BST {
      * type NODE.
      */
     createNode(key, value) {
-        return new AVLTreeNode(key, value);
+        return new AVLTreeNode(key, this._isMapMode ? undefined : value);
     }
     /**
      * The function creates a new AVL tree with the specified options and returns it.

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

@@ -75,7 +75,7 @@ class BinaryTree extends base_1.IterableEntryBase {
     constructor(keysNodesEntriesOrRaws = [], options) {
         super();
         this.iterationType = 'ITERATIVE';
-        this._isMapMode = false;
+        this._isMapMode = true;
         this._store = new Map();
         this._size = 0;
         this._NIL = new BinaryTreeNode(NaN);
@@ -122,7 +122,7 @@ class BinaryTree extends base_1.IterableEntryBase {
      * as NODE.
      */
     createNode(key, value) {
-        return new BinaryTreeNode(key, value);
+        return new BinaryTreeNode(key, this._isMapMode ? undefined : value);
     }
     /**
      * The function creates a binary tree with the specified options.

package/dist/data-structures/binary-tree/bst.js

@@ -106,7 +106,7 @@ class BST extends binary_tree_1.BinaryTree {
      * @returns The method is returning a new instance of the BSTNode class, casted as the NODE type.
      */
     createNode(key, value) {
-        return new BSTNode(key, value);
+        return new BSTNode(key, this._isMapMode ? undefined : value);
     }
     /**
      * The function creates a new binary search tree with the specified options.
@@ -128,10 +128,10 @@ class BST extends binary_tree_1.BinaryTree {
      * @returns either a NODE object or undefined.
      */
     keyValueNodeEntryRawToNodeAndValue(keyNodeEntryOrRaw, value) {
-        const [node, tValue] = super.keyValueNodeEntryRawToNodeAndValue(keyNodeEntryOrRaw, value);
+        const [node, entryValue] = super.keyValueNodeEntryRawToNodeAndValue(keyNodeEntryOrRaw, value);
         if (node === null)
             return [undefined, undefined];
-        return [node, tValue !== null && tValue !== void 0 ? tValue : value];
+        return [node, value !== null && value !== void 0 ? value : entryValue];
     }
     /**
      * Time Complexity: O(log n)
@@ -199,6 +199,8 @@ class BST extends binary_tree_1.BinaryTree {
         while (current !== undefined) {
             if (this.comparator(current.key, newNode.key) === 0) {
                 this._replaceNode(current, newNode);
+                if (this._isMapMode)
+                    this._setValue(current.key, newValue);
                 return true;
             }
             else if (this.comparator(current.key, newNode.key) > 0) {

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

@@ -74,7 +74,7 @@ class RedBlackTree extends bst_1.BST {
      * returned.
      */
     createNode(key, value, color = 'BLACK') {
-        return new RedBlackTreeNode(key, value, color);
+        return new RedBlackTreeNode(key, this._isMapMode ? undefined : value, color);
     }
     /**
      * The function creates a new Red-Black Tree with the specified options.
@@ -177,8 +177,12 @@ class RedBlackTree extends bst_1.BST {
             this._size++;
             return true;
         }
-        else
-            return insertStatus === 'UPDATED';
+        if (insertStatus === 'UPDATED') {
+            if (this._isMapMode)
+                this._setValue(newNode.key, newValue);
+            return true;
+        }
+        return false;
     }
     /**
      * Time Complexity: O(log n)

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

@@ -88,7 +88,7 @@ class TreeMultiMap extends rb_tree_1.RedBlackTree {
      * @returns A new instance of the TreeMultiMapNode class, casted as NODE.
      */
     createNode(key, value, color = 'BLACK', count) {
-        return new TreeMultiMapNode(key, value, count, color);
+        return new TreeMultiMapNode(key, this._isMapMode ? undefined : value, count, color);
     }
     /**
      * The function creates a new instance of a TreeMultiMap with the specified options and returns it.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bst-typed",
-  "version": "1.53.0",
+  "version": "1.53.1",
   "description": "BST (Binary Search Tree). Javascript & Typescript Data Structure.",
   "main": "dist/index.js",
   "scripts": {
@@ -144,6 +144,6 @@
     "typescript": "^4.9.5"
   },
   "dependencies": {
-    "data-structure-typed": "^1.53.0"
+    "data-structure-typed": "^1.53.1"
   }
 }

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

@@ -129,7 +129,7 @@ export class AVLTreeMultiMap<
    * @returns a new instance of the AVLTreeMultiMapNode class, casted as NODE.
    */
   override createNode(key: K, value?: V, count?: number): NODE {
-    return new AVLTreeMultiMapNode(key, value, count) as NODE;
+    return new AVLTreeMultiMapNode(key, this._isMapMode ? undefined : value, count) as NODE;
   }
 
   /**

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

@@ -99,7 +99,7 @@ export class AVLTree<
    * type NODE.
    */
   override createNode(key: K, value?: V): NODE {
-    return new AVLTreeNode<K, V, NODE>(key, value) as NODE;
+    return new AVLTreeNode<K, V, NODE>(key, this._isMapMode ? undefined : value) as NODE;
   }
 
   /**

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

@@ -135,7 +135,7 @@ export class BinaryTree<
     if (keysNodesEntriesOrRaws) this.addMany(keysNodesEntriesOrRaws);
   }
 
-  protected _isMapMode = false;
+  protected _isMapMode = true;
 
   get isMapMode() {
     return this._isMapMode;
@@ -181,7 +181,7 @@ export class BinaryTree<
    * as NODE.
    */
   createNode(key: K, value?: V): NODE {
-    return new BinaryTreeNode<K, V, NODE>(key, value) as NODE;
+    return new BinaryTreeNode<K, V, NODE>(key, this._isMapMode ? undefined : value) as NODE;
   }
 
   /**

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

@@ -141,7 +141,7 @@ export class BST<
    * @returns The method is returning a new instance of the BSTNode class, casted as the NODE type.
    */
   override createNode(key: K, value?: V): NODE {
-    return new BSTNode<K, V, NODE>(key, value) as NODE;
+    return new BSTNode<K, V, NODE>(key, this._isMapMode ? undefined : value) as NODE;
   }
 
   /**
@@ -174,9 +174,9 @@ export class BST<
     keyNodeEntryOrRaw: BTNRep<K, V, NODE> | R,
     value?: V
   ): [OptNode<NODE>, V | undefined] {
-    const [node, tValue] = super.keyValueNodeEntryRawToNodeAndValue(keyNodeEntryOrRaw, value);
+    const [node, entryValue] = super.keyValueNodeEntryRawToNodeAndValue(keyNodeEntryOrRaw, value);
     if (node === null) return [undefined, undefined];
-    return [node, tValue ?? value];
+    return [node, value ?? entryValue];
   }
 
   /**
@@ -250,6 +250,7 @@ export class BST<
     while (current !== undefined) {
       if (this.comparator(current.key, newNode.key) === 0) {
         this._replaceNode(current, newNode);
+        if (this._isMapMode) this._setValue(current.key, newValue);
         return true;
       } else if (this.comparator(current.key, newNode.key) > 0) {
         if (current.left === undefined) {

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

@@ -106,7 +106,7 @@ export class RedBlackTree<
    * returned.
    */
   override createNode(key: K, value?: V, color: RBTNColor = 'BLACK'): NODE {
-    return new RedBlackTreeNode<K, V, NODE>(key, value, color) as NODE;
+    return new RedBlackTreeNode<K, V, NODE>(key, this._isMapMode ? undefined : value, color) as NODE;
   }
 
   /**
@@ -218,7 +218,12 @@ export class RedBlackTree<
       if (this._isMapMode) this._setValue(newNode.key, newValue);
       this._size++;
       return true;
-    } else return insertStatus === 'UPDATED';
+    }
+    if (insertStatus === 'UPDATED') {
+      if (this._isMapMode) this._setValue(newNode.key, newValue);
+      return true;
+    }
+    return false;
   }
 
   /**

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

@@ -124,7 +124,7 @@ export class TreeMultiMap<
    * @returns A new instance of the TreeMultiMapNode class, casted as NODE.
    */
   override createNode(key: K, value?: V, color: RBTNColor = 'BLACK', count?: number): NODE {
-    return new TreeMultiMapNode(key, value, count, color) as NODE;
+    return new TreeMultiMapNode(key, this._isMapMode ? undefined : value, count, color) as NODE;
   }
 
   /**

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

@@ -9,9 +9,9 @@ export type BinaryTreeNested<K, V, R, NODE extends BinaryTreeNode<K, V, NODE>> =
 export type ToEntryFn<K, V, R> = (rawElement: R) => BTNEntry<K, V>;
 
 export type BinaryTreeOptions<K, V, R> = {
-    iterationType?: IterationType;
-    toEntryFn?: ToEntryFn<K, V, R>;
-    isMapMode?: boolean;
+  iterationType?: IterationType;
+  toEntryFn?: ToEntryFn<K, V, R>;
+  isMapMode?: boolean;
 }
 
 export type BinaryTreePrintOptions = { isShowUndefined?: boolean; isShowNull?: boolean; isShowRedBlackNIL?: boolean };

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

@@ -7,7 +7,7 @@ export type BSTNodeNested<K, V> = BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTN
 export type BSTNested<K, V, R, NODE extends BSTNode<K, V, NODE>> = BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
 
 export type BSTOptions<K, V, R> = BinaryTreeOptions<K, V, R> & {
-    comparator?: Comparator<K>
+  comparator?: Comparator<K>
 }
 
 export type BSTNOptKey<K> = K | undefined;