min-heap-typed 1.54.0 → 1.54.1

package/src/data-structures/graph/directed-graph.ts

@@ -45,6 +45,9 @@ export class DirectedEdge<E = any> extends AbstractEdge<E> {
   }
 }
 
+/**
+ *
+ */
 export class DirectedGraph<
     V = any,
     E = any,

package/src/data-structures/graph/map-graph.ts

@@ -40,6 +40,9 @@ export class MapEdge<E = any> extends DirectedEdge<E> {
   }
 }
 
+/**
+ *
+ */
 export class MapGraph<
   V = any,
   E = any,

package/src/data-structures/graph/undirected-graph.ts

@@ -42,6 +42,9 @@ export class UndirectedEdge<E = number> extends AbstractEdge<E> {
   }
 }
 
+/**
+ *
+ */
 export class UndirectedGraph<
     V = any,
     E = any,

package/src/data-structures/linked-list/singly-linked-list.ts

@@ -59,6 +59,9 @@ export class SinglyLinkedListNode<E = any> {
   }
 }
 
+/**
+ *
+ */
 export class SinglyLinkedList<E = any, R = any> extends IterableElementBase<E, R, SinglyLinkedList<E, R>> {
   constructor(
     elements: Iterable<E> | Iterable<R> | Iterable<SinglyLinkedListNode<E>> = [],

package/src/data-structures/linked-list/skip-linked-list.ts

@@ -19,6 +19,9 @@ export class SkipListNode<K, V> {
   }
 }
 
+/**
+ *
+ */
 export class SkipList<K, V> {
   /**
    * The constructor function initializes a SkipLinkedList object with optional options and elements.

package/src/data-structures/matrix/matrix.ts

@@ -7,6 +7,9 @@
  */
 import type { MatrixOptions } from '../../types';
 
+/**
+ *
+ */
 export class Matrix {
   /**
    * The constructor function initializes a matrix object with the provided data and options, or with

package/src/data-structures/matrix/navigator.ts

@@ -25,6 +25,9 @@ export class Character {
   }
 }
 
+/**
+ *
+ */
 export class Navigator<T = number> {
   onMove: (cur: [number, number]) => void;
   protected readonly _matrix: T[][];

package/src/data-structures/priority-queue/max-priority-queue.ts

@@ -8,6 +8,9 @@
 import type { Comparator, ElementCallback, PriorityQueueOptions } from '../../types';
 import { PriorityQueue } from './priority-queue';
 
+/**
+ *
+ */
 export class MaxPriorityQueue<E = any, R = any> extends PriorityQueue<E, R> {
   /**
    * The constructor initializes a PriorityQueue with optional elements and options, including a

package/src/data-structures/priority-queue/min-priority-queue.ts

@@ -8,6 +8,9 @@
 import type { Comparator, ElementCallback, PriorityQueueOptions } from '../../types';
 import { PriorityQueue } from './priority-queue';
 
+/**
+ *
+ */
 export class MinPriorityQueue<E = any, R = any> extends PriorityQueue<E, R> {
   /**
    * The constructor initializes a PriorityQueue with optional elements and options, including a

package/src/data-structures/trie/trie.ts

@@ -8,10 +8,6 @@
 import type { ElementCallback, TrieOptions } from '../../types';
 import { IterableElementBase } from '../base';
 
-/**
- * TrieNode represents a node in the Trie data structure. It holds a character key, a map of children nodes,
- * and a flag indicating whether it's the end of a word.
- */
 export class TrieNode {
   constructor(key: string) {
     this._key = key;

package/src/interfaces/binary-tree.ts

@@ -1,30 +1,16 @@
-import { BinaryTree, BinaryTreeNode } from '../data-structures';
-import type {
-  BinaryTreeDeleteResult,
-  BinaryTreeNested,
-  BinaryTreeNodeNested,
-  BinaryTreeOptions,
-  BTNRep,
-  NodePredicate
-} from '../types';
+import { BinaryTreeNode } from '../data-structures';
+import type { BinaryTreeDeleteResult, BinaryTreeOptions, BTNRep, NodePredicate } from '../types';
 
-export interface IBinaryTree<
-  K = any,
-  V = any,
-  R = object,
-  MK = any,
-  MV = any,
-  MR = object,
-  NODE extends BinaryTreeNode<K, V, NODE> = BinaryTreeNodeNested<K, V>,
-  TREE extends BinaryTree<K, V, R, MK, MV, MR, NODE, TREE> = BinaryTreeNested<K, V, R, MK, MV, MR, NODE>
-> {
-  createNode(key: K, value?: NODE['value']): NODE;
+export interface IBinaryTree<K = any, V = any, R = object, MK = any, MV = any, MR = object> {
+  createNode(key: K, value?: BinaryTreeNode['value']): BinaryTreeNode;
 
-  createTree(options?: Partial<BinaryTreeOptions<K, V, R>>): TREE;
+  createTree(options?: Partial<BinaryTreeOptions<K, V, R>>): IBinaryTree<K, V, R, MK, MV, MR>;
 
-  add(keyOrNodeOrEntryOrRawElement: BTNRep<K, V, NODE>, value?: V, count?: number): boolean;
+  add(keyOrNodeOrEntryOrRawElement: BTNRep<K, V, BinaryTreeNode<K, V>>, value?: V, count?: number): boolean;
 
-  addMany(nodes: Iterable<BTNRep<K, V, NODE>>, values?: Iterable<V | undefined>): boolean[];
+  addMany(nodes: Iterable<BTNRep<K, V, BinaryTreeNode<K, V>>>, values?: Iterable<V | undefined>): boolean[];
 
-  delete(predicate: R | BTNRep<K, V, NODE> | NodePredicate<NODE>): BinaryTreeDeleteResult<NODE>[];
+  delete(
+    predicate: R | BTNRep<K, V, BinaryTreeNode<K, V>> | NodePredicate<BinaryTreeNode<K, V>>
+  ): BinaryTreeDeleteResult<BinaryTreeNode<K, V>>[];
 }

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

@@ -0,0 +1,3 @@
+import { AVLTreeOptions } from './avl-tree';
+
+export type AVLTreeCounterOptions<K, V, R> = AVLTreeOptions<K, V, R> & {};

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

@@ -1,8 +1,3 @@
-import { AVLTreeMultiMap, AVLTreeMultiMapNode } from '../../../data-structures';
 import type { AVLTreeOptions } from './avl-tree';
 
-export type AVLTreeMultiMapNodeNested<K, V> = AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, any>>>
-
-export type AVLTreeMultiMapNested<K, V, R, MK, MV, MR, NODE extends AVLTreeMultiMapNode<K, V, NODE>> = AVLTreeMultiMap<K, V, R, MK, MV, MR, NODE, AVLTreeMultiMap<K, V, R, MK, MV, MR, NODE, AVLTreeMultiMap<K, V, R, MK, MV, MR, NODE, any>>>
-
-export type AVLTreeMultiMapOptions<K, V, R> = AVLTreeOptions<K, V, R> & {}
+export type AVLTreeMultiMapOptions<K, V, R> = Omit<AVLTreeOptions<K, V, R>, 'isMapMode'> & {}

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

@@ -1,8 +1,3 @@
-import { AVLTree, AVLTreeNode } from '../../../data-structures';
 import { BSTOptions } from './bst';
 
-export type AVLTreeNodeNested<K, V> = AVLTreeNode<K, V, AVLTreeNode<K, V, AVLTreeNode<K, V, any>>>
-
-export type AVLTreeNested<K, V, R,MK, MV, MR,  NODE extends AVLTreeNode<K, V, NODE>> = AVLTree<K, V, R,MK, MV, MR,  NODE, AVLTree<K, V, R,MK, MV, MR,  NODE, AVLTree<K, V, R,MK, MV, MR,  NODE, any>>>
-
 export type AVLTreeOptions<K, V, R> = BSTOptions<K, V, R> & {};

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

@@ -1,11 +1,6 @@
-import { BinaryTree, BinaryTreeNode } from '../../../data-structures';
 import { IterationType, OptValue } from '../../common';
 import { DFSOperation } from '../../../common';
 
-export type BinaryTreeNodeNested<K, V> = BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V,  any>>>
-
-export type BinaryTreeNested<K, V, R, MK, MV, MR, NODE extends BinaryTreeNode<K, V, NODE>> = BinaryTree<K, V, R, MK, MV, MR, NODE,BinaryTree<K, V, R, MK, MV, MR, NODE,BinaryTree<K, V, R, MK, MV, MR, NODE,any>>>
-
 export type ToEntryFn<K, V, R> = (rawElement: R) => BTNEntry<K, V>;
 
 export type BinaryTreeOptions<K, V, R> = {

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

@@ -1,10 +1,6 @@
-import { BST, BSTNode } from '../../../data-structures';
 import type { BinaryTreeOptions } from './binary-tree';
 import { Comparable } from '../../utils';
-
-export type BSTNodeNested<K, V> = BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, any>>>
-
-export type BSTNested<K, V, R,MK, MV, MR,  NODE extends BSTNode<K, V, NODE>> = BST<K, V, R,MK, MV, MR,  NODE,BST<K, V, R,MK, MV, MR,  NODE,BST<K, V, R,MK, MV, MR,  NODE, any>>>
+import { OptValue } from '../../common';
 
 export type BSTOptions<K, V, R> = BinaryTreeOptions<K, V, R> & {
   specifyComparable?: (key: K) => Comparable
@@ -15,5 +11,9 @@ export type BSTNOptKey<K> = K | undefined;
 
 export type OptNode<NODE> = NODE | undefined;
 
+export type BSTNEntry<K, V> = [BSTNOptKey<K>, OptValue<V>];
+
 export type BSTNOptKeyOrNode<K, NODE> = BSTNOptKey<K> | NODE;
 
+export type BSTNRep<K, V, NODE> = BSTNEntry<K, V> | BSTNOptKeyOrNode<K, NODE>;
+

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

@@ -5,3 +5,5 @@ export * from './segment-tree';
 export * from './avl-tree-multi-map';
 export * from './rb-tree';
 export * from './tree-multi-map';
+export * from './tree-counter';
+export * from './avl-tree-counter';

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

@@ -1,10 +1,5 @@
-import { RedBlackTree, RedBlackTreeNode } from '../../../data-structures';
-import type { BSTOptions } from "./bst";
+import type { BSTOptions } from './bst';
 
 export type RBTNColor = 'RED' | 'BLACK';
 
-export type RedBlackTreeNodeNested<K, V> = RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, any>>>
-
-export type RedBlackTreeNested<K, V, R, MK, MV, MR, NODE extends RedBlackTreeNode<K, V, NODE>> = RedBlackTree<K, V, R, MK, MV, MR, NODE, RedBlackTree<K, V, R, MK, MV, MR, NODE, RedBlackTree<K, V, R, MK, MV, MR, NODE, any>>>
-
 export type RedBlackTreeOptions<K, V, R> = BSTOptions<K, V, R> & {};

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

@@ -0,0 +1,3 @@
+import type { RedBlackTreeOptions } from './rb-tree';
+
+export type TreeCounterOptions<K, V, R> = RedBlackTreeOptions<K, V, R> & {};

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

@@ -1,8 +1,3 @@
-import { TreeMultiMap, TreeMultiMapNode } from '../../../data-structures';
 import type { RedBlackTreeOptions } from './rb-tree';
 
-export type TreeMultiMapNodeNested<K, V> = TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, any>>>
-
-export type TreeMultiMapNested<K, V, R, MK, MV, MR, NODE extends TreeMultiMapNode<K, V, NODE>> = TreeMultiMap<K, V, R, MK, MV, MR, NODE, TreeMultiMap<K, V, R, MK, MV, MR, NODE,TreeMultiMap<K, V, R, MK, MV, MR, NODE, any>>>
-
-export type TreeMultiMapOptions<K, V, R> = RedBlackTreeOptions<K, V, R> & {}
+export type TreeMultiMapOptions<K, V, R> = Omit<RedBlackTreeOptions<K, V, R>, 'isMapMode'> & {}