data-structure-typed 1.52.9 → 1.53.1

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

@@ -49,7 +49,7 @@ export class AVLTree extends BST {
     /**
      * This is a constructor function for an AVLTree class that initializes the tree with keys, nodes,
      * entries, or raw elements.
-     * @param keysOrNodesOrEntriesOrRaws - The `keysOrNodesOrEntriesOrRaws` parameter is an
+     * @param keysNodesEntriesOrRaws - The `keysNodesEntriesOrRaws` parameter is an
      * iterable object that can contain either keys, nodes, entries, or raw elements. These elements will
      * be used to initialize the AVLTree.
      * @param [options] - The `options` parameter is an optional object that can be used to customize the
@@ -57,10 +57,10 @@ export class AVLTree extends BST {
      * keys), `allowDuplicates` (a boolean indicating whether duplicate keys are allowed), and
      * `nodeBuilder` (
      */
-    constructor(keysOrNodesOrEntriesOrRaws = [], options) {
+    constructor(keysNodesEntriesOrRaws = [], options) {
         super([], options);
-        if (keysOrNodesOrEntriesOrRaws)
-            super.addMany(keysOrNodesOrEntriesOrRaws);
+        if (keysNodesEntriesOrRaws)
+            super.addMany(keysNodesEntriesOrRaws);
     }
     /**
      * The function creates a new AVL tree node with the given key and value.
@@ -72,7 +72,7 @@ export class AVLTree extends 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.
@@ -84,6 +84,7 @@ export class AVLTree extends BST {
     createTree(options) {
         return new AVLTree([], {
             iterationType: this.iterationType,
+            isMapMode: this._isMapMode,
             comparator: this._comparator,
             toEntryFn: this._toEntryFn,
             ...options
@@ -91,13 +92,13 @@ export class AVLTree extends BST {
     }
     /**
      * The function checks if the input is an instance of AVLTreeNode.
-     * @param {BTNKeyOrNodeOrEntry<K, V, NODE> | R} keyOrNodeOrEntryOrRaw - The parameter
-     * `keyOrNodeOrEntryOrRaw` can be of type `R` or `BTNKeyOrNodeOrEntry<K, V, NODE>`.
-     * @returns a boolean value indicating whether the input parameter `keyOrNodeOrEntryOrRaw` is
+     * @param {BTNRep<K, V, NODE> | R} keyNodeEntryOrRaw - The parameter
+     * `keyNodeEntryOrRaw` can be of type `R` or `BTNRep<K, V, NODE>`.
+     * @returns a boolean value indicating whether the input parameter `keyNodeEntryOrRaw` is
      * an instance of the `AVLTreeNode` class.
      */
-    isNode(keyOrNodeOrEntryOrRaw) {
-        return keyOrNodeOrEntryOrRaw instanceof AVLTreeNode;
+    isNode(keyNodeEntryOrRaw) {
+        return keyNodeEntryOrRaw instanceof AVLTreeNode;
     }
     /**
      * Time Complexity: O(log n)
@@ -105,19 +106,19 @@ export class AVLTree extends BST {
      *
      * The function overrides the add method of a class and inserts a key-value pair into a data
      * structure, then balances the path.
-     * @param {BTNKeyOrNodeOrEntry<K, V, NODE> | R} keyOrNodeOrEntryOrRaw - The parameter
-     * `keyOrNodeOrEntryOrRaw` can accept values of type `R`, `BTNKeyOrNodeOrEntry<K, V, NODE>`, or
+     * @param {BTNRep<K, V, NODE> | R} keyNodeEntryOrRaw - The parameter
+     * `keyNodeEntryOrRaw` can accept values of type `R`, `BTNRep<K, V, NODE>`, or
      * `RawElement`.
      * @param {V} [value] - The `value` parameter is an optional value that you want to associate with
      * the key or node being added to the data structure.
      * @returns The method is returning a boolean value.
      */
-    add(keyOrNodeOrEntryOrRaw, value) {
-        if (keyOrNodeOrEntryOrRaw === null)
+    add(keyNodeEntryOrRaw, value) {
+        if (keyNodeEntryOrRaw === null)
             return false;
-        const inserted = super.add(keyOrNodeOrEntryOrRaw, value);
+        const inserted = super.add(keyNodeEntryOrRaw, value);
         if (inserted)
-            this._balancePath(keyOrNodeOrEntryOrRaw);
+            this._balancePath(keyNodeEntryOrRaw);
         return inserted;
     }
     /**
@@ -126,15 +127,15 @@ export class AVLTree extends BST {
      *
      * The function overrides the delete method in a TypeScript class, performs deletion, and then
      * balances the tree if necessary.
-     * @param {BTNKeyOrNodeOrEntry<K, V, NODE> | R} keyOrNodeOrEntryOrRaw - The `keyOrNodeOrEntryOrRaw`
+     * @param {BTNRep<K, V, NODE> | R} keyNodeEntryOrRaw - The `keyNodeEntryOrRaw`
      * parameter in the `override delete` method can be one of the following types:
      * @returns The `delete` method is being overridden in this code snippet. It first calls the `delete`
      * method from the superclass (presumably a parent class) with the provided `predicate`, which could
      * be a key, node, entry, or a custom predicate. The result of this deletion operation is stored in
      * `deletedResults`, which is an array of `BinaryTreeDeleteResult` objects.
      */
-    delete(keyOrNodeOrEntryOrRaw) {
-        const deletedResults = super.delete(keyOrNodeOrEntryOrRaw);
+    delete(keyNodeEntryOrRaw) {
+        const deletedResults = super.delete(keyNodeEntryOrRaw);
         for (const { needBalanced } of deletedResults) {
             if (needBalanced) {
                 this._balancePath(needBalanced);
@@ -148,10 +149,10 @@ export class AVLTree extends BST {
      *
      * The `_swapProperties` function swaps the key, value, and height properties between two nodes in a
      * binary search tree.
-     * @param {R | BSTNKeyOrNode<K, NODE>} srcNode - The `srcNode` parameter represents either a node
+     * @param {R | BSTNOptKeyOrNode<K, NODE>} srcNode - The `srcNode` parameter represents either a node
      * object (`NODE`) or a key-value pair (`R`) that is being swapped with another node.
-     * @param {R | BSTNKeyOrNode<K, NODE>} destNode - The `destNode` parameter is either an instance of
-     * `R` or an instance of `BSTNKeyOrNode<K, NODE>`.
+     * @param {R | BSTNOptKeyOrNode<K, NODE>} destNode - The `destNode` parameter is either an instance of
+     * `R` or an instance of `BSTNOptKeyOrNode<K, NODE>`.
      * @returns The method is returning the `destNodeEnsured` object if both `srcNodeEnsured` and
      * `destNodeEnsured` are truthy. Otherwise, it returns `undefined`.
      */
@@ -164,10 +165,12 @@ export class AVLTree extends BST {
             if (tempNode) {
                 tempNode.height = height;
                 destNodeEnsured.key = srcNodeEnsured.key;
-                destNodeEnsured.value = srcNodeEnsured.value;
+                if (!this._isMapMode)
+                    destNodeEnsured.value = srcNodeEnsured.value;
                 destNodeEnsured.height = srcNodeEnsured.height;
                 srcNodeEnsured.key = tempNode.key;
-                srcNodeEnsured.value = tempNode.value;
+                if (!this._isMapMode)
+                    srcNodeEnsured.value = tempNode.value;
                 srcNodeEnsured.height = tempNode.height;
             }
             return destNodeEnsured;
@@ -404,8 +407,8 @@ export class AVLTree extends BST {
      *
      * The `_balancePath` function is used to update the heights of nodes and perform rotation operations
      * to restore balance in an AVL tree after inserting a node.
-     * @param {BTNKeyOrNodeOrEntry<K, V, NODE> | R} node - The `node` parameter can be of type `R` or
-     * `BTNKeyOrNodeOrEntry<K, V, NODE>`.
+     * @param {BTNRep<K, V, NODE> | R} node - The `node` parameter can be of type `R` or
+     * `BTNRep<K, V, NODE>`.
      */
     _balancePath(node) {
         node = this.ensureNode(node);