@gesslar/toolkit 0.1.5 → 0.1.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gesslar/toolkit",
-  "version": "0.1.5",
+  "version": "0.1.6",
   "description": "Get in, bitches, we're going toolkitting.",
   "main": "./src/index.js",
   "type": "module",

package/src/lib/Util.js

@@ -230,4 +230,66 @@ export default class Util {
       )
     }
   }
+
+  /**
+   * Determine the Levenshtein distance between two string values
+   *
+   * @param {string} a The first value for comparison.
+   * @param {string} b The second value for comparison.
+   * @returns {number} The Levenshtein distance
+   */
+  static levenshteinDistance(a, b) {
+    const matrix = Array.from({length: a.length + 1}, (_, i) =>
+      Array.from({length: b.length + 1}, (_, j) =>
+        (i === 0 ? j : j === 0 ? i : 0)
+      )
+    )
+
+    for(let i = 1; i <= a.length; i++) {
+      for(let j = 1; j <= b.length; j++) {
+        matrix[i][j] =
+          a[i - 1] === b[j - 1]
+            ? matrix[i - 1][j - 1]
+            : 1 + Math.min(
+              matrix[i - 1][j], matrix[i][j - 1],
+              matrix[i - 1][j - 1]
+            )
+      }
+    }
+
+    return matrix[a.length][b.length]
+  }
+
+  /**
+   * Determine the closest match between a string and allowed values
+   * from the Levenshtein distance.
+   *
+   * @param {string} input The input string to resolve
+   * @param {Array<string>} allowedValues The values which are permitted
+   * @param {number} [threshold] Max edit distance for a "close match"
+   * @returns {string} Suggested, probable match.
+   */
+  static findClosestMatch(input, allowedValues, threshold=2) {
+    let closestMatch = null
+    let closestDistance = Infinity
+    let closestLengthDiff = Infinity
+
+    for(const value of allowedValues) {
+      const distance = Util.levenshteinDistance(input, value)
+      const lengthDiff = Math.abs(input.length - value.length)
+
+      if(distance < closestDistance && distance <= threshold) {
+        closestMatch = value
+        closestDistance = distance
+        closestLengthDiff = lengthDiff
+      } else if(distance === closestDistance &&
+                 distance <= threshold &&
+                 lengthDiff < closestLengthDiff) {
+        closestMatch = value
+        closestLengthDiff = lengthDiff
+      }
+    }
+
+    return closestMatch
+  }
 }

package/src/types/Util.d.ts

@@ -174,6 +174,46 @@ declare class Util {
    * @returns Resolves when all listeners have completed
    */
   static asyncEmitAnon(emitter: { listeners(event: string): Function[], on(event: string, listener: Function): any, emit(event: string, ...args: unknown[]): any }, event: string, ...args: unknown[]): Promise<void>
+
+  /**
+   * Determine the Levenshtein distance between two string values.
+   * The Levenshtein distance is the minimum number of single-character edits
+   * (insertions, deletions, or substitutions) required to change one string into another.
+   *
+   * @param a - The first string for comparison
+   * @param b - The second string for comparison
+   * @returns The Levenshtein distance (number of edits needed)
+   *
+   * @example
+   * ```typescript
+   * Util.levenshteinDistance("kitten", "sitting") // 3
+   * Util.levenshteinDistance("book", "back") // 2
+   * Util.levenshteinDistance("hello", "hello") // 0
+   * ```
+   */
+  static levenshteinDistance(a: string, b: string): number
+
+  /**
+   * Find the closest match between an input string and an array of allowed values
+   * using Levenshtein distance. Returns the closest match if it's within a threshold
+   * of 2 edits, otherwise returns null.
+   *
+   * Useful for fuzzy string matching, such as suggesting corrections for typos
+   * in command-line arguments or configuration values.
+   *
+   * @param input - The input string to find a match for
+   * @param allowedValues - Array of allowed string values to match against
+   * @param threshold - Maximum edit distance for a match (default: 2)
+   * @returns The closest matching string, or null if no match within threshold
+   *
+   * @example
+   * ```typescript
+   * const commands = ["help", "build", "test", "deploy"]
+   * Util.findClosestMatch("bulid", commands) // "build"
+   * Util.findClosestMatch("xyz", commands) // null
+   * ```
+   */
+  static findClosestMatch(input: string, allowedValues: string[], threshold?: number): string | null
 }
 
 export default Util