directed-graph-typed 1.54.1 → 1.54.3

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

@@ -5,11 +5,13 @@
  * @copyright Copyright (c) 2022 Pablo Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import { AVLTreeMultiMapOptions, BTNOptKeyOrNull, BTNRep, OptNodeOrNull } from '../../types';
+import { AVLTreeMultiMapOptions, BTNOptKeyOrNull } from '../../types';
 import { AVLTree, AVLTreeNode } from './avl-tree';
 import { IBinaryTree } from '../../interfaces';
 
 export class AVLTreeMultiMapNode<K = any, V = any> extends AVLTreeNode<K, V[]> {
+  override parent?: AVLTreeMultiMapNode<K, V> = undefined;
+
   /**
    * This TypeScript constructor initializes an object with a key of type K and an array of values of
    * type V.
@@ -23,28 +25,26 @@ export class AVLTreeMultiMapNode<K = any, V = any> extends AVLTreeNode<K, V[]> {
     super(key, value);
   }
 
-  override parent?: AVLTreeMultiMapNode<K, V> = undefined;
-
-  override _left?: OptNodeOrNull<AVLTreeMultiMapNode<K, V>> = undefined;
+  override _left?: AVLTreeMultiMapNode<K, V> | null | undefined = undefined;
 
-  override get left(): OptNodeOrNull<AVLTreeMultiMapNode<K, V>> {
+  override get left(): AVLTreeMultiMapNode<K, V> | null | undefined {
     return this._left;
   }
 
-  override set left(v: OptNodeOrNull<AVLTreeMultiMapNode<K, V>>) {
+  override set left(v: AVLTreeMultiMapNode<K, V> | null | undefined) {
     if (v) {
       v.parent = this;
     }
     this._left = v;
   }
 
-  override _right?: OptNodeOrNull<AVLTreeMultiMapNode<K, V>> = undefined;
+  override _right?: AVLTreeMultiMapNode<K, V> | null | undefined = undefined;
 
-  override get right(): OptNodeOrNull<AVLTreeMultiMapNode<K, V>> {
+  override get right(): AVLTreeMultiMapNode<K, V> | null | undefined {
     return this._right;
   }
 
-  override set right(v: OptNodeOrNull<AVLTreeMultiMapNode<K, V>>) {
+  override set right(v: AVLTreeMultiMapNode<K, V> | null | undefined) {
     if (v) {
       v.parent = this;
     }
@@ -71,7 +71,9 @@ export class AVLTreeMultiMap<K = any, V = any, R = object, MK = any, MV = any, M
    * additional options for configuring the AVLTreeMultiMap instance.
    */
   constructor(
-    keysNodesEntriesOrRaws: Iterable<BTNRep<K, V[], AVLTreeMultiMapNode<K, V>> | R> = [],
+    keysNodesEntriesOrRaws: Iterable<
+      K | AVLTreeMultiMapNode<K, V> | [K | null | undefined, V[] | undefined] | null | undefined | R
+    > = [],
     options?: AVLTreeMultiMapOptions<K, V[], R>
   ) {
     super([], { ...options, isMapMode: true });
@@ -117,7 +119,9 @@ export class AVLTreeMultiMap<K = any, V = any, R = object, MK = any, MV = any, M
     return new AVLTreeMultiMapNode<K, V>(key, []);
   }
 
-  override add(node: BTNRep<K, V[], AVLTreeMultiMapNode<K, V>>): boolean;
+  override add(
+    node: K | AVLTreeMultiMapNode<K, V> | [K | null | undefined, V[] | undefined] | null | undefined
+  ): boolean;
 
   override add(key: K, value: V): boolean;
 
@@ -127,7 +131,7 @@ export class AVLTreeMultiMap<K = any, V = any, R = object, MK = any, MV = any, M
    *
    * The function `add` in TypeScript overrides the superclass method to add key-value pairs to an AVL
    * tree multi-map.
-   * @param {BTNRep<K, V[], AVLTreeMultiMapNode<K, V>> | K} keyNodeOrEntry - The `keyNodeOrEntry`
+   * @param {K | AVLTreeMultiMapNode<K, V> | [K | null | undefined, V[] | undefined] | null | undefined | K} keyNodeOrEntry - The `keyNodeOrEntry`
    * parameter in the `override add` method can be either a key-value pair entry or just a key. If it
    * is a key-value pair entry, it will be in the format `[key, values]`, where `key` is the key and
    * `values`
@@ -137,7 +141,10 @@ export class AVLTreeMultiMap<K = any, V = any, R = object, MK = any, MV = any, M
    * @returns The `override add` method is returning a boolean value, which indicates whether the
    * addition operation was successful or not.
    */
-  override add(keyNodeOrEntry: BTNRep<K, V[], AVLTreeMultiMapNode<K, V>> | K, value?: V): boolean {
+  override add(
+    keyNodeOrEntry: K | AVLTreeMultiMapNode<K, V> | [K | null | undefined, V[] | undefined] | null | undefined | K,
+    value?: V
+  ): boolean {
     if (this.isRealNode(keyNodeOrEntry)) return super.add(keyNodeOrEntry);
 
     const _commonAdd = (key?: BTNOptKeyOrNull<K>, values?: V[]) => {
@@ -180,7 +187,7 @@ export class AVLTreeMultiMap<K = any, V = any, R = object, MK = any, MV = any, M
    *
    * The function `deleteValue` removes a specific value from a key in an AVLTreeMultiMap data
    * structure and deletes the entire node if no values are left for that key.
-   * @param {BTNRep<K, V[], AVLTreeMultiMapNode<K, V>> | K} keyNodeOrEntry - The `keyNodeOrEntry`
+   * @param {K | AVLTreeMultiMapNode<K, V> | [K | null | undefined, V[] | undefined] | null | undefined | K} keyNodeOrEntry - The `keyNodeOrEntry`
    * parameter in the `deleteValue` function can be either a `BTNRep` object representing a key-value
    * pair in the AVLTreeMultiMapNode, or just the key itself.
    * @param {V} value - The `value` parameter in the `deleteValue` function represents the specific
@@ -191,7 +198,10 @@ export class AVLTreeMultiMap<K = any, V = any, R = object, MK = any, MV = any, M
    * `value` was successfully deleted from the array of values associated with the `keyNodeOrEntry`. If
    * the value was not found in the array, it returns `false`.
    */
-  deleteValue(keyNodeOrEntry: BTNRep<K, V[], AVLTreeMultiMapNode<K, V>> | K, value: V): boolean {
+  deleteValue(
+    keyNodeOrEntry: K | AVLTreeMultiMapNode<K, V> | [K | null | undefined, V[] | undefined] | null | undefined | K,
+    value: V
+  ): boolean {
     const values = this.get(keyNodeOrEntry);
     if (Array.isArray(values)) {
       const index = values.indexOf(value);

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

@@ -6,17 +6,12 @@
  * @license MIT License
  */
 import { BST, BSTNode } from './bst';
-import type {
-  AVLTreeOptions,
-  BinaryTreeDeleteResult,
-  BSTNOptKeyOrNode,
-  BTNRep,
-  EntryCallback,
-  OptNodeOrNull
-} from '../../types';
+import type { AVLTreeOptions, BinaryTreeDeleteResult, BSTNOptKeyOrNode, EntryCallback } from '../../types';
 import { IBinaryTree } from '../../interfaces';
 
 export class AVLTreeNode<K = any, V = any> extends BSTNode<K, V> {
+  override parent?: AVLTreeNode<K, V> = undefined;
+
   /**
    * This TypeScript constructor function initializes an instance with a key and an optional value.
    * @param {K} key - The `key` parameter is typically used to uniquely identify an object or element
@@ -30,28 +25,26 @@ export class AVLTreeNode<K = any, V = any> extends BSTNode<K, V> {
     super(key, value);
   }
 
-  override parent?: AVLTreeNode<K, V> = undefined;
-
-  override _left?: OptNodeOrNull<AVLTreeNode<K, V>> = undefined;
+  override _left?: AVLTreeNode<K, V> | null | undefined = undefined;
 
-  override get left(): OptNodeOrNull<AVLTreeNode<K, V>> {
+  override get left(): AVLTreeNode<K, V> | null | undefined {
     return this._left;
   }
 
-  override set left(v: OptNodeOrNull<AVLTreeNode<K, V>>) {
+  override set left(v: AVLTreeNode<K, V> | null | undefined) {
     if (v) {
       v.parent = this;
     }
     this._left = v;
   }
 
-  override _right?: OptNodeOrNull<AVLTreeNode<K, V>> = undefined;
+  override _right?: AVLTreeNode<K, V> | null | undefined = undefined;
 
-  override get right(): OptNodeOrNull<AVLTreeNode<K, V>> {
+  override get right(): AVLTreeNode<K, V> | null | undefined {
     return this._right;
   }
 
-  override set right(v: OptNodeOrNull<AVLTreeNode<K, V>>) {
+  override set right(v: AVLTreeNode<K, V> | null | undefined) {
     if (v) {
       v.parent = this;
     }
@@ -76,7 +69,8 @@ export class AVLTree<K = any, V = any, R = object, MK = any, MV = any, MR = obje
    * This TypeScript constructor initializes an AVLTree with keys, nodes, entries, or raw data provided
    * in an iterable format.
    * @param keysNodesEntriesOrRaws - The `keysNodesEntriesOrRaws` parameter in the constructor is an
-   * iterable that can contain either `BTNRep<K, V, AVLTreeNode<K, V>>` objects or `R` objects. It is
+   * iterable that can contain either `
+   K | AVLTreeNode<K, V> | [K | null | undefined, V | undefined]  | null | undefined ` objects or `R` objects. It is
    * used to initialize the AVLTree with key-value pairs or raw data entries. If provided
    * @param [options] - The `options` parameter in the constructor is of type `AVLTreeOptions<K, V,
    * R>`. It is an optional parameter that allows you to specify additional options for configuring the
@@ -84,7 +78,9 @@ export class AVLTree<K = any, V = any, R = object, MK = any, MV = any, MR = obje
    * other configuration settings specific
    */
   constructor(
-    keysNodesEntriesOrRaws: Iterable<BTNRep<K, V, AVLTreeNode<K, V>> | R> = [],
+    keysNodesEntriesOrRaws: Iterable<
+      K | AVLTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined | R
+    > = [],
     options?: AVLTreeOptions<K, V, R>
   ) {
     super([], options);
@@ -133,12 +129,15 @@ export class AVLTree<K = any, V = any, R = object, MK = any, MV = any, MR = obje
    * Space Complexity: O(1)
    *
    * The function checks if the input is an instance of AVLTreeNode.
-   * @param {BTNRep<K, V, AVLTreeNode<K, V>>} keyNodeOrEntry - The parameter
-   * `keyNodeOrEntry` can be of type `R` or `BTNRep<K, V, AVLTreeNode<K, V>>`.
+   * @param {K | AVLTreeNode<K, V> | [K | null | undefined, V | undefined]  | null | undefined } keyNodeOrEntry - The parameter
+   * `keyNodeOrEntry` can be of type `R` or `
+   K | AVLTreeNode<K, V> | [K | null | undefined, V | undefined]  | null | undefined `.
    * @returns a boolean value indicating whether the input parameter `keyNodeOrEntry` is
    * an instance of the `AVLTreeNode` class.
    */
-  override isNode(keyNodeOrEntry: BTNRep<K, V, AVLTreeNode<K, V>>): keyNodeOrEntry is AVLTreeNode<K, V> {
+  override isNode(
+    keyNodeOrEntry: K | AVLTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined
+  ): keyNodeOrEntry is AVLTreeNode<K, V> {
     return keyNodeOrEntry instanceof AVLTreeNode;
   }
 
@@ -148,13 +147,17 @@ export class AVLTree<K = any, V = any, R = object, MK = any, MV = any, MR = obje
    *
    * The function overrides the add method of a class and inserts a key-value pair into a data
    * structure, then balances the path.
-   * @param {BTNRep<K, V, AVLTreeNode<K, V>>} keyNodeOrEntry - The parameter
-   * `keyNodeOrEntry` can accept values of type `R`, `BTNRep<K, V, AVLTreeNode<K, V>>`
+   * @param { K | AVLTreeNode<K, V> | [K | null | undefined, V | undefined]  | null | undefined } keyNodeOrEntry - The parameter
+   * `keyNodeOrEntry` can accept values of type `R`, `
+   K | AVLTreeNode<K, V> | [K | null | undefined, V | undefined]  | null | undefined `
    * @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.
    */
-  override add(keyNodeOrEntry: BTNRep<K, V, AVLTreeNode<K, V>>, value?: V): boolean {
+  override add(
+    keyNodeOrEntry: K | AVLTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined,
+    value?: V
+  ): boolean {
     if (keyNodeOrEntry === null) return false;
     const inserted = super.add(keyNodeOrEntry, value);
     if (inserted) this._balancePath(keyNodeOrEntry);
@@ -167,14 +170,16 @@ export class AVLTree<K = any, V = any, R = object, MK = any, MV = any, MR = obje
    *
    * The function overrides the delete method in a TypeScript class, performs deletion, and then
    * balances the tree if necessary.
-   * @param {BTNRep<K, V, AVLTreeNode<K, V>>} keyNodeOrEntry - The `keyNodeOrEntry`
+   * @param { K | AVLTreeNode<K, V> | [K | null | undefined, V | undefined]  | null | undefined } keyNodeOrEntry - The `keyNodeOrEntry`
    * 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.
    */
-  override delete(keyNodeOrEntry: BTNRep<K, V, AVLTreeNode<K, V>>): BinaryTreeDeleteResult<AVLTreeNode<K, V>>[] {
+  override delete(
+    keyNodeOrEntry: K | AVLTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined
+  ): BinaryTreeDeleteResult<AVLTreeNode<K, V>>[] {
     const deletedResults = super.delete(keyNodeOrEntry);
     for (const { needBalanced } of deletedResults) {
       if (needBalanced) {
@@ -487,10 +492,11 @@ export class AVLTree<K = any, V = any, R = object, MK = any, MV = any, MR = obje
    *
    * 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 {BTNRep<K, V, AVLTreeNode<K, V>>} node - The `node` parameter can be of type `R` or
-   * `BTNRep<K, V, AVLTreeNode<K, V>>`.
+   * @param { K | AVLTreeNode<K, V> | [K | null | undefined, V | undefined]  | null | undefined } node - The `node` parameter can be of type `R` or
+   * `
+   K | AVLTreeNode<K, V> | [K | null | undefined, V | undefined]  | null | undefined `.
    */
-  protected _balancePath(node: BTNRep<K, V, AVLTreeNode<K, V>>): void {
+  protected _balancePath(node: K | AVLTreeNode<K, V> | [K | null | undefined, V | undefined] | null | undefined): void {
     node = this.ensureNode(node);
     const path = this.getPathToRoot(node, node => node, false); // first O(log n) + O(log n)
     for (let i = 0; i < path.length; i++) {