vivth 1.5.3 → 1.5.4

package/README.md

@@ -3924,9 +3924,9 @@ f.forInSignals((key, signal) => {
 
 #### reference: `WalkThrough`
 
-- collection of static `methods` to walktrhough things, instead of regular looping;
-- usefull to iterator that might be modified during iteration;
-- mostlikely to be less performant, but with better result clarity;
+- collection of static `methods` to walkthrough things, instead of regular looping;
+- useful for iterators that might be modified during iteration;
+- most likely to be less performant, but with better result clarity;
 
 #### reference: `WalkThrough.set`
 
@@ -3936,7 +3936,7 @@ f.forInSignals((key, signal) => {
 /**
  * @template VAL
  * @param {Set<VAL>} setInstance
- * @param {(value:VAL)=>void} callback
+ * @param {(value: VAL) => void} callback
  * @returns {void}
  */
 ```
@@ -3958,7 +3958,7 @@ WalkThrough.set(setOfSomething, (value) => {
 /**
  * @template KEY, VAL
  * @param {Map<KEY, VAL>} mapInstance
- * @param {(res:[key: KEY, value: VAL]) => void} callback
+ * @param {(entry: [key: KEY, value: VAL]) => void} callback
  * @returns {void}
  */
 ```
@@ -3980,7 +3980,7 @@ WalkThrough.map(mapOfSomething, ([key, value]) => {
 /**
  * @template VAL
  * @param {VAL[]} arrayInstance
- * @param {(res:[value: VAL, index: number]) => void} callback
+ * @param {(entry: [index: number, value: VAL]) => void} callback
  * @returns {void}
  */
 ```
@@ -3989,7 +3989,7 @@ WalkThrough.map(mapOfSomething, ([key, value]) => {
 
 ```js
 import { WalkThrough } from "vivth/neutral";
-WalkThrough.array(arrayOfSomething, ([value, index]) => {
+WalkThrough.array(arrayOfSomething, ([index, value]) => {
   // code
 });
 ```

package/generated/types/src/class/WalkThrough.d.mts

@@ -1,28 +1,29 @@
 /**
  * @description
- * - collection of static `methods` to walktrhough things, instead of regular looping;
- * - usefull to iterator that might be modified during iteration;
- * - mostlikely to be less performant, but with better result clarity;
+ * - collection of static `methods` to walkthrough things, instead of regular looping;
+ * - useful for iterators that might be modified during iteration;
+ * - most likely to be less performant, but with better result clarity;
  */
 export class WalkThrough {
     /**
-     * @param {Iterator<any, any, any>} iterator
-     * @param {(...any:any[])=>void} callback
+     * @template T
+     * @param {Iterator<T, any, any>} iterator
+     * @param {(value: T) => void} callback
      * @returns {void}
      */
-    static #handler: (iterator: Iterator<any, any, any>, callback: (...any: any[]) => void) => void;
+    static #handler<T>(iterator: Iterator<T, any, any>, callback: (value: T) => void): void;
     /**
      * @description
      * - method helper to WalkThrough `Set`;
      * @template VAL
      * @param {Set<VAL>} setInstance
-     * @param {(value:VAL)=>void} callback
+     * @param {(value: VAL) => void} callback
      * @returns {void}
      * @example
      * import { WalkThrough } from 'vivth/neutral';
      *
      * WalkThrough.set(setOfSomething, (value) => {
-     * 	// code
+     * // code
      * })
      */
     static set<VAL>(setInstance: Set<VAL>, callback: (value: VAL) => void): void;
@@ -31,29 +32,29 @@ export class WalkThrough {
      * - method helper to WalkThrough `Map`;
      * @template KEY, VAL
      * @param {Map<KEY, VAL>} mapInstance
-     * @param {(res:[key: KEY, value: VAL]) => void} callback
+     * @param {(entry: [key: KEY, value: VAL]) => void} callback
      * @returns {void}
      * @example
      * import { WalkThrough } from 'vivth/neutral';
      *
      * WalkThrough.map(mapOfSomething, ([key, value]) => {
-     * 	// code
+     * // code
      * })
      */
-    static map<KEY, VAL>(mapInstance: Map<KEY, VAL>, callback: (res: [key: KEY, value: VAL]) => void): void;
+    static map<KEY, VAL>(mapInstance: Map<KEY, VAL>, callback: (entry: [key: KEY, value: VAL]) => void): void;
     /**
      * @description
      * - method helper to WalkThrough `Array`;
      * @template VAL
      * @param {VAL[]} arrayInstance
-     * @param {(res:[value: VAL, index: number]) => void} callback
+     * @param {(entry: [index: number, value: VAL]) => void} callback
      * @returns {void}
      * @example
      * import { WalkThrough } from 'vivth/neutral';
      *
-     * WalkThrough.array(arrayOfSomething, ([value, index]) => {
-     * 	// code
+     * WalkThrough.array(arrayOfSomething, ([index, value]) => {
+     * // code
      * })
      */
-    static array<VAL>(arrayInstance: VAL[], callback: (res: [value: VAL, index: number]) => void): void;
+    static array<VAL>(arrayInstance: VAL[], callback: (entry: [index: number, value: VAL]) => void): void;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vivth",
-  "version": "1.5.3",
+  "version": "1.5.4",
   "description": "library primitives",
   "devDependencies": {
     "@types/bun": "^1.3.3",

package/src/class/WalkThrough.mjs

@@ -2,72 +2,77 @@
 
 /**
  * @description
- * - collection of static `methods` to walktrhough things, instead of regular looping;
- * - usefull to iterator that might be modified during iteration;
- * - mostlikely to be less performant, but with better result clarity;
+ * - collection of static `methods` to walkthrough things, instead of regular looping;
+ * - useful for iterators that might be modified during iteration;
+ * - most likely to be less performant, but with better result clarity;
  */
 export class WalkThrough {
 	/**
-	 * @param {Iterator<any, any, any>} iterator
-	 * @param {(...any:any[])=>void} callback
+	 * @template T
+	 * @param {Iterator<T, any, any>} iterator
+	 * @param {(value: T) => void} callback
 	 * @returns {void}
 	 */
-	static #handler = (iterator, callback) => {
+	static #handler(iterator, callback) {
 		let result = iterator.next();
 		while (!result.done) {
 			callback(result.value);
 			result = iterator.next();
 		}
-	};
+	}
+
 	/**
 	 * @description
 	 * - method helper to WalkThrough `Set`;
 	 * @template VAL
 	 * @param {Set<VAL>} setInstance
-	 * @param {(value:VAL)=>void} callback
+	 * @param {(value: VAL) => void} callback
 	 * @returns {void}
 	 * @example
 	 * import { WalkThrough } from 'vivth/neutral';
 	 *
 	 * WalkThrough.set(setOfSomething, (value) => {
-	 * 	// code
+	 * // code
 	 * })
 	 */
 	static set(setInstance, callback) {
 		WalkThrough.#handler(setInstance.values(), callback);
 	}
+
 	/**
 	 * @description
 	 * - method helper to WalkThrough `Map`;
 	 * @template KEY, VAL
 	 * @param {Map<KEY, VAL>} mapInstance
-	 * @param {(res:[key: KEY, value: VAL]) => void} callback
+	 * @param {(entry: [key: KEY, value: VAL]) => void} callback
 	 * @returns {void}
 	 * @example
 	 * import { WalkThrough } from 'vivth/neutral';
 	 *
 	 * WalkThrough.map(mapOfSomething, ([key, value]) => {
-	 * 	// code
+	 * // code
 	 * })
 	 */
 	static map(mapInstance, callback) {
 		WalkThrough.#handler(mapInstance.entries(), callback);
 	}
+
 	/**
 	 * @description
 	 * - method helper to WalkThrough `Array`;
 	 * @template VAL
 	 * @param {VAL[]} arrayInstance
-	 * @param {(res:[value: VAL, index: number]) => void} callback
+	 * @param {(entry: [index: number, value: VAL]) => void} callback
 	 * @returns {void}
 	 * @example
 	 * import { WalkThrough } from 'vivth/neutral';
 	 *
-	 * WalkThrough.array(arrayOfSomething, ([value, index]) => {
-	 * 	// code
+	 * WalkThrough.array(arrayOfSomething, ([index, value]) => {
+	 * // code
 	 * })
 	 */
 	static array(arrayInstance, callback) {
-		WalkThrough.#handler(arrayInstance.values(), callback);
+		// Changed .values() to .entries() to match your [index, value] requirement
+		WalkThrough.#handler(arrayInstance.entries(), callback);
 	}
 }