avl-tree-typed 2.2.6 → 2.2.8

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

@@ -204,7 +204,7 @@ export class TreeCounter<K = any, V = any, R = any> extends RedBlackTree<K, V, R
     options?: TreeCounterOptions<K, V, R>
   ) {
     super([], options);
-    if (keysNodesEntriesOrRaws) this.addMany(keysNodesEntriesOrRaws);
+    if (keysNodesEntriesOrRaws) this.setMany(keysNodesEntriesOrRaws);
   }
 
   protected _count = 0;
@@ -255,14 +255,14 @@ export class TreeCounter<K = any, V = any, R = any> extends RedBlackTree<K, V, R
    * @param [count] - How much to increase the node's count (default 1).
    * @returns True if inserted/updated; false if ignored.
    */
-  override add(
+  override set(
     keyNodeOrEntry: K | TreeCounterNode<K, V> | [K | null | undefined, V | undefined] | null | undefined,
     value?: V,
     count = 1
   ): boolean {
     const [newNode, newValue] = this._keyValueNodeOrEntryToNodeAndValue(keyNodeOrEntry, value, count);
     const orgCount = newNode?.count || 0;
-    const isSuccessAdded = super.add(newNode, newValue);
+    const isSuccessAdded = super.set(newNode, newValue);
     if (isSuccessAdded) {
       this._count += orgCount;
       return true;
@@ -437,7 +437,7 @@ export class TreeCounter<K = any, V = any, R = any> extends RedBlackTree<K, V, R
 
     let index = 0;
     for (const [key, value] of this) {
-      out.add(callback.call(thisArg, value, key, index++, this));
+      out.set(callback.call(thisArg, value, key, index++, this));
     }
     return out;
   }

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

@@ -364,7 +364,7 @@ export class TreeMultiMap<K = any, V = any, R = any> extends RedBlackTree<K, V[]
   ) {
     super([], { ...options });
     if (keysNodesEntriesOrRaws) {
-      this.addMany(keysNodesEntriesOrRaws);
+      this.setMany(keysNodesEntriesOrRaws);
     }
   }
 
@@ -385,29 +385,29 @@ export class TreeMultiMap<K = any, V = any, R = any> extends RedBlackTree<K, V[]
     return keyNodeOrEntry instanceof TreeMultiMapNode;
   }
 
-  override add(
+  override set(
     keyNodeOrEntry: K | TreeMultiMapNode<K, V> | [K | null | undefined, V[] | undefined] | null | undefined
   ): boolean;
 
-  override add(key: K, value: V): boolean;
+  override set(key: K, value: V): boolean;
 
   /**
    * Insert a value or a list of values into the multimap. If the key exists, values are appended.
    * @remarks Time O(log N + M), Space O(1)
    * @param keyNodeOrEntry - Key, node, or [key, values] entry.
-   * @param [value] - Single value to add when a bare key is provided.
+   * @param [value] - Single value to set when a bare key is provided.
    * @returns True if inserted or appended; false if ignored.
    */
-  override add(
+  override set(
     keyNodeOrEntry: K | TreeMultiMapNode<K, V> | [K | null | undefined, V[] | undefined] | null | undefined,
     value?: V
   ): boolean {
-    if (this.isRealNode(keyNodeOrEntry)) return super.add(keyNodeOrEntry);
+    if (this.isRealNode(keyNodeOrEntry)) return super.set(keyNodeOrEntry);
 
     const _commonAdd = (key?: BTNOptKeyOrNull<K>, values?: V[]) => {
       if (key === undefined || key === null) return false;
 
-      const _addToValues = () => {
+      const _setToValues = () => {
         const existingValues = this.get(key);
         if (existingValues !== undefined && values !== undefined) {
           for (const value of values) existingValues.push(value);
@@ -416,12 +416,12 @@ export class TreeMultiMap<K = any, V = any, R = any> extends RedBlackTree<K, V[]
         return false;
       };
 
-      const _addByNode = () => {
+      const _setByNode = () => {
         const existingNode = this.getNode(key);
         if (this.isRealNode(existingNode)) {
           const existingValues = this.get(existingNode);
           if (existingValues === undefined) {
-            super.add(key, values);
+            super.set(key, values);
             return true;
           }
           if (values !== undefined) {
@@ -431,14 +431,14 @@ export class TreeMultiMap<K = any, V = any, R = any> extends RedBlackTree<K, V[]
             return false;
           }
         } else {
-          return super.add(key, values);
+          return super.set(key, values);
         }
       };
 
       if (this._isMapMode) {
-        return _addByNode() || _addToValues();
+        return _setByNode() || _setToValues();
       }
-      return _addToValues() || _addByNode();
+      return _setToValues() || _setByNode();
     };
 
     if (this.isEntry(keyNodeOrEntry)) {
@@ -503,7 +503,7 @@ export class TreeMultiMap<K = any, V = any, R = any> extends RedBlackTree<K, V[]
   ): RedBlackTree<MK, MV, MR> {
     const out = this._createLike<MK, MV, MR>([], options);
     let i = 0;
-    for (const [k, v] of this) out.add(callback.call(thisArg, v, k, i++, this));
+    for (const [k, v] of this) out.set(callback.call(thisArg, v, k, i++, this));
     return out;
   }