undirected-graph-typed 1.54.0 → 1.54.1

package/dist/data-structures/linked-list/singly-linked-list.d.ts

@@ -40,6 +40,9 @@ export declare class SinglyLinkedListNode<E = any> {
      */
     set next(value: SinglyLinkedListNode<E> | undefined);
 }
+/**
+ *
+ */
 export declare class SinglyLinkedList<E = any, R = any> extends IterableElementBase<E, R, SinglyLinkedList<E, R>> {
     constructor(elements?: Iterable<E> | Iterable<R> | Iterable<SinglyLinkedListNode<E>>, options?: SinglyLinkedListOptions<E, R>);
     protected _head: SinglyLinkedListNode<E> | undefined;

package/dist/data-structures/linked-list/singly-linked-list.js

@@ -45,6 +45,9 @@ class SinglyLinkedListNode {
     }
 }
 exports.SinglyLinkedListNode = SinglyLinkedListNode;
+/**
+ *
+ */
 class SinglyLinkedList extends base_1.IterableElementBase {
     constructor(elements = [], options) {
         super(options);

package/dist/data-structures/linked-list/skip-linked-list.d.ts

@@ -12,6 +12,9 @@ export declare class SkipListNode<K, V> {
     forward: SkipListNode<K, V>[];
     constructor(key: K, value: V, level: number);
 }
+/**
+ *
+ */
 export declare class SkipList<K, V> {
     /**
      * The constructor function initializes a SkipLinkedList object with optional options and elements.

package/dist/data-structures/linked-list/skip-linked-list.js

@@ -9,6 +9,9 @@ class SkipListNode {
     }
 }
 exports.SkipListNode = SkipListNode;
+/**
+ *
+ */
 class SkipList {
     /**
      * The constructor function initializes a SkipLinkedList object with optional options and elements.

package/dist/data-structures/matrix/matrix.d.ts

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

package/dist/data-structures/matrix/matrix.js

@@ -1,6 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Matrix = void 0;
+/**
+ *
+ */
 class Matrix {
     /**
      * The constructor function initializes a matrix object with the provided data and options, or with

package/dist/data-structures/matrix/navigator.d.ts

@@ -19,6 +19,9 @@ export declare class Character {
      */
     constructor(direction: Direction, turning: Turning);
 }
+/**
+ *
+ */
 export declare class Navigator<T = number> {
     onMove: (cur: [number, number]) => void;
     protected readonly _matrix: T[][];

package/dist/data-structures/matrix/navigator.js

@@ -16,6 +16,9 @@ class Character {
     }
 }
 exports.Character = Character;
+/**
+ *
+ */
 class Navigator {
     /**
      * The constructor initializes the Navigator object with the given parameters and sets the current position as visited

package/dist/data-structures/priority-queue/max-priority-queue.d.ts

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

package/dist/data-structures/priority-queue/max-priority-queue.js

@@ -2,6 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MaxPriorityQueue = void 0;
 const priority_queue_1 = require("./priority-queue");
+/**
+ *
+ */
 class MaxPriorityQueue extends priority_queue_1.PriorityQueue {
     /**
      * The constructor initializes a PriorityQueue with optional elements and options, including a

package/dist/data-structures/priority-queue/min-priority-queue.d.ts

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

package/dist/data-structures/priority-queue/min-priority-queue.js

@@ -2,6 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MinPriorityQueue = void 0;
 const priority_queue_1 = require("./priority-queue");
+/**
+ *
+ */
 class MinPriorityQueue extends priority_queue_1.PriorityQueue {
     /**
      * The constructor initializes a PriorityQueue with optional elements and options, including a

package/dist/data-structures/trie/trie.d.ts

@@ -7,10 +7,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 declare class TrieNode {
     constructor(key: string);
     protected _key: string;

package/dist/data-structures/trie/trie.js

@@ -2,10 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Trie = exports.TrieNode = void 0;
 const base_1 = require("../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.
- */
 class TrieNode {
     constructor(key) {
         this._key = key;

package/dist/interfaces/binary-tree.d.ts

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

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

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

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

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -1,5 +1,2 @@
-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/dist/types/data-structures/binary-tree/avl-tree.d.ts

@@ -1,5 +1,2 @@
-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/dist/types/data-structures/binary-tree/binary-tree.d.ts

@@ -1,8 +1,5 @@
-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> = {
     iterationType?: IterationType;

package/dist/types/data-structures/binary-tree/bst.d.ts

@@ -1,12 +1,12 @@
-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;
     isReverse?: boolean;
 };
 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/dist/types/data-structures/binary-tree/index.d.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/dist/types/data-structures/binary-tree/index.js

@@ -21,3 +21,5 @@ __exportStar(require("./segment-tree"), exports);
 __exportStar(require("./avl-tree-multi-map"), exports);
 __exportStar(require("./rb-tree"), exports);
 __exportStar(require("./tree-multi-map"), exports);
+__exportStar(require("./tree-counter"), exports);
+__exportStar(require("./avl-tree-counter"), exports);

package/dist/types/data-structures/binary-tree/rb-tree.d.ts

@@ -1,6 +1,3 @@
-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/dist/types/data-structures/binary-tree/tree-counter.d.ts

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

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

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -1,5 +1,2 @@
-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'> & {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "undirected-graph-typed",
-  "version": "1.54.0",
+  "version": "1.54.1",
   "description": "Undirected Graph. Javascript & Typescript Data Structure.",
   "main": "dist/index.js",
   "scripts": {
@@ -145,6 +145,6 @@
     "typescript": "^4.9.5"
   },
   "dependencies": {
-    "data-structure-typed": "^1.54.0"
+    "data-structure-typed": "^1.54.1"
   }
 }