directed-graph-typed 2.2.0 → 2.2.2

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

@@ -125,7 +125,9 @@ export declare class AVLTreeNode<K = any, V = any> {
  * 4. Order Preservation: Maintains the binary search tree property where left child values are less than the parent, and right child values are greater.
  * 5. Efficient Lookups: Offers O(log n) search time, where 'n' is the number of nodes, due to its balanced nature.
  * 6. Complex Insertions and Deletions: Due to rebalancing, these operations are more complex than in a regular BST.
- * 7. Path Length: The path length from the root to any leaf is longer compared to an unbalanced BST, but shorter than a linear chain of nodes.@example
+ * 7. Path Length: The path length from the root to any leaf is longer compared to an unbalanced BST, but shorter than a linear chain of nodes.
+ *
+ * @example
  * // Find elements in a range
  *     // In interval queries, AVL trees, with their strictly balanced structure and lower height, offer better query efficiency, making them ideal for frequent and high-performance interval queries. In contrast, Red-Black trees, with lower update costs, are more suitable for scenarios involving frequent insertions and deletions where the requirements for interval queries are less demanding.
  *     type Datum = { timestamp: Date; temperature: number };

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

@@ -123,6 +123,7 @@ export declare class BinaryTreeNode<K = any, V = any> {
  * 3. Depth and Height: Depth is the number of edges from the root to a node; height is the maximum depth in the tree.
  * 4. Subtrees: Each child of a node forms the root of a subtree.
  * 5. Leaf Nodes: Nodes without children are leaves.
+ *
  * @example
  * // determine loan approval using a decision tree
  *     // Decision tree structure

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

@@ -124,6 +124,7 @@ export declare class BSTNode<K = any, V = any> {
  * 5. Logarithmic Operations: Ideal operations like insertion, deletion, and searching are O(log n) time-efficient.
  * 6. Balance Variability: Can become unbalanced; special types maintain balance.
  * 7. No Auto-Balancing: Standard BSTs don't automatically balance themselves.
+ *
  * @example
  * // Merge 3 sorted datasets
  *     const dataset1 = new BST<number, string>([

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

@@ -110,6 +110,7 @@ export declare class RedBlackTreeNode<K = any, V = any> {
  * @template R
  * 1. Efficient self-balancing, but not completely balanced. Compared with AVLTree, the addition and deletion efficiency is high, but the query efficiency is slightly lower.
  * 2. It is BST itself. Compared with Heap which is not completely ordered, RedBlackTree is completely ordered.
+ *
  * @example
  * // using Red-Black Tree as a price-based index for stock data
  *     // Define the structure of individual stock records

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

@@ -113,6 +113,7 @@ export declare class TreeMultiMapNode<K = any, V = any> {
  * @template K
  * @template V
  * @template R
+ *
  * @example
  * // players ranked by score with their equipment
  *     type Equipment = {

package/dist/types/types/data-structures/base/base.d.ts

@@ -1,6 +1,6 @@
 import { IterableElementBase, IterableEntryBase } from '../../../data-structures';
 import { LinearBase } from '../../../data-structures/base/linear-base';
-export type EntryCallback<K, V, R> = (key: K, value: V, index: number, original: IterableEntryBase<K, V>) => R;
+export type EntryCallback<K, V, R> = (value: V, key: K, index: number, original: IterableEntryBase<K, V>) => R;
 export type ElementCallback<E, R, RT> = (element: E, index: number, original: IterableElementBase<E, R>) => RT;
 export type ReduceEntryCallback<K, V, R> = (accumulator: R, value: V, key: K, index: number, original: IterableEntryBase<K, V>) => R;
 export type ReduceElementCallback<E, R, U = E> = (accumulator: U, value: E, index: number, self: IterableElementBase<E, R>) => U;

package/dist/umd/directed-graph-typed.js

@@ -133,7 +133,7 @@ var directedGraphTyped = (() => {
     every(predicate, thisArg) {
       let index = 0;
       for (const item of this) {
-        if (!predicate.call(thisArg, item[0], item[1], index++, this)) {
+        if (!predicate.call(thisArg, item[1], item[0], index++, this)) {
           return false;
         }
       }
@@ -149,7 +149,7 @@ var directedGraphTyped = (() => {
     some(predicate, thisArg) {
       let index = 0;
       for (const item of this) {
-        if (predicate.call(thisArg, item[0], item[1], index++, this)) {
+        if (predicate.call(thisArg, item[1], item[0], index++, this)) {
           return true;
         }
       }
@@ -165,7 +165,7 @@ var directedGraphTyped = (() => {
       let index = 0;
       for (const item of this) {
         const [key, value] = item;
-        callbackfn.call(thisArg, key, value, index++, this);
+        callbackfn.call(thisArg, value, key, index++, this);
       }
     }
     /**
@@ -179,7 +179,7 @@ var directedGraphTyped = (() => {
       let index = 0;
       for (const item of this) {
         const [key, value] = item;
-        if (callbackfn.call(thisArg, key, value, index++, this)) return item;
+        if (callbackfn.call(thisArg, value, key, index++, this)) return item;
       }
       return;
     }
@@ -2126,7 +2126,7 @@ var directedGraphTyped = (() => {
       const filtered = [];
       let index = 0;
       for (const [key, value] of this) {
-        if (predicate.call(thisArg, key, value, index, this)) {
+        if (predicate.call(thisArg, value, key, index, this)) {
           filtered.push([key, value]);
         }
         index++;
@@ -2141,7 +2141,7 @@ var directedGraphTyped = (() => {
       const filtered = [];
       let index = 0;
       for (const [key, value] of this) {
-        if (predicate.call(thisArg, key, value, index, this)) {
+        if (predicate.call(thisArg, value, key, index, this)) {
           filtered.push([key, value]);
         }
         index++;
@@ -2152,7 +2152,7 @@ var directedGraphTyped = (() => {
       const mapped = [];
       let index = 0;
       for (const [key, value] of this) {
-        mapped.push(callback.call(thisArg, key, value, index, this));
+        mapped.push(callback.call(thisArg, value, key, index, this));
         index++;
       }
       return mapped;