@gesslar/toolkit 0.1.5 → 0.2.0

package/package.json

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

package/src/lib/Data.js

@@ -8,6 +8,7 @@
 
 import Sass from "./Sass.js"
 import TypeSpec from "./TypeSpec.js"
+import Util from "./Util.js"
 import Valid from "./Valid.js"
 
 export default class Data {
@@ -19,17 +20,17 @@ export default class Data {
  */
   static primitives = Object.freeze([
   // Primitives
-    "undefined",
-    "null",
-    "boolean",
-    "number",
-    "bigint",
-    "string",
-    "symbol",
+    "Undefined",
+    "Null",
+    "Boolean",
+    "Number",
+    "Bigint",
+    "String",
+    "Symbol",
 
     // Object Categories from typeof
-    "object",
-    "function",
+    "Object",
+    "Function",
   ])
 
   /**
@@ -67,7 +68,7 @@ export default class Data {
    */
   static dataTypes = Object.freeze([
     ...Data.primitives,
-    ...Data.constructors.map(c => c.toLowerCase())
+    ...Data.constructors
   ])
 
   /**
@@ -76,7 +77,7 @@ export default class Data {
    *
    * @type {Array<string>}
    */
-  static emptyableTypes = Object.freeze(["string", "array", "object"])
+  static emptyableTypes = Object.freeze(["String", "Array", "Object"])
 
   /**
    * Appends a string to another string if it does not already end with it.
@@ -109,8 +110,11 @@ export default class Data {
    * @returns {boolean} Whether all elements are of the specified type
    */
   static isArrayUniform(arr, type) {
+    const checkType = type ? Util.capitalize(type) : null
+
     return arr.every(
-      (item, _index, arr) => typeof item === (type || typeof arr[0]),
+      (item, _index, arr) =>
+        Data.typeOf(item) === (checkType || Data.typeOf(arr[0])),
     )
   }
 
@@ -197,10 +201,10 @@ export default class Data {
     const result = {}
 
     for(const [key, value] of Object.entries(obj)) {
-      if(Data.isType(value, "array")) {
+      if(Data.isType(value, "Array")) {
         // Clone arrays by mapping over them
         result[key] = value.map(item =>
-          Data.isType(item, "object") || Data.isType(item, "array")
+          Data.isType(item, "object") || Data.isType(item, "Array")
             ? Data.cloneObject(item)
             : item
         )
@@ -227,25 +231,25 @@ export default class Data {
       workSpec = [],
       result = {}
 
-    if(!Data.isType(source, "array", {allowEmpty: false}))
+    if(!Data.isType(source, "Array", {allowEmpty: false}))
       throw Sass.new("Source must be an array.")
 
     workSource.push(...source)
 
     if(
-      !Data.isType(spec, "array", {allowEmpty: false}) &&
+      !Data.isType(spec, "Array", {allowEmpty: false}) &&
       !Data.isType(spec, "function")
     )
       throw Sass.new("Spec must be an array or a function.")
 
-    if(Data.isType(spec, "function")) {
+    if(Data.isType(spec, "Function")) {
       const specResult = await spec(workSource)
 
-      if(!Data.isType(specResult, "array"))
+      if(!Data.isType(specResult, "Array"))
         throw Sass.new("Spec resulting from function must be an array.")
 
       workSpec.push(...specResult)
-    } else if(Data.isType(spec, "array", {allowEmpty: false})) {
+    } else if(Data.isType(spec, "Array", {allowEmpty: false})) {
       workSpec.push(...spec)
     }
 
@@ -256,7 +260,7 @@ export default class Data {
     workSource.map((element, index, arr) => (arr[index] = String(element)))
 
     // Check that all keys are strings
-    if(!Data.isArrayUniform(workSource, "string"))
+    if(!Data.isArrayUniform(workSource, "String"))
       throw Sass.new("Indices of an Object must be of type string.")
 
     workSource.forEach((element, index) => (result[element] = workSpec[index]))
@@ -332,7 +336,13 @@ export default class Data {
    * @returns {boolean} Whether the type is valid
    */
   static isValidType(type) {
-    return Data.dataTypes.includes(type)
+    // Allow built-in types
+    if(Data.dataTypes.includes(type)) {
+      return true
+    }
+
+    // Allow custom classes (PascalCase starting with capital letter)
+    return /^[A-Z][a-zA-Z0-9]*$/.test(type)
   }
 
   /**
@@ -349,16 +359,13 @@ export default class Data {
       return false
 
     const valueType = Data.typeOf(value)
-    const normalizedType = type.toLowerCase()
 
     // Special cases that need extra validation
-    switch(normalizedType) {
-      case "number":
-        return valueType === "number" && !isNaN(value) // Excludes NaN
-      case "object":
-        return valueType === "object" && value !== null && !Array.isArray(value) // Excludes arrays and null
+    switch(valueType) {
+      case "Number":
+        return valueType === "Number" && !isNaN(value) // Excludes NaN
       default:
-        return valueType === normalizedType
+        return valueType === type
     }
   }
 
@@ -370,12 +377,13 @@ export default class Data {
    */
   static typeOf(value) {
     if(value === null)
-      return "null"
+      return "Null"
 
-    if(Array.isArray(value))
-      return "array"
+    const type = typeof value
 
-    return typeof value
+    return type === "object"
+      ? value.constructor.name
+      : type.charAt(0).toUpperCase() + type.slice(1)
   }
 
   /**
@@ -412,12 +420,12 @@ export default class Data {
       return false
 
     switch(type) {
-      case "array":
+      case "Array":
         return value.length === 0
-      case "object":
+      case "Object":
         // null was already handled above, so this should only be real objects
         return Object.keys(value).length === 0
-      case "string":
+      case "String":
         return value.trim().length === 0
       default:
         return false

package/src/lib/TypeSpec.js

@@ -6,6 +6,7 @@
 
 import Sass from "./Sass.js"
 import Data from "./Data.js"
+import Util from "./Util.js"
 
 /**
  * Type specification class for parsing and validating complex type definitions.
@@ -149,7 +150,7 @@ export default class TypeSpec {
     // Now, let's do some checking with the types, respecting the array flag
     // with the value
     const valueType = Data.typeOf(value)
-    const isArray = valueType === "array"
+    const isArray = valueType === "Array"
 
     // We need to ensure that we match the type and the consistency of the types
     // in an array, if it is an array and an array is allowed.
@@ -166,8 +167,8 @@ export default class TypeSpec {
 
       // Handle array values
       if(isArray) {
-        // Special case for generic "array" type
-        if(allowedType === "array" && !allowedArray)
+        // Special case for generic "Array" type
+        if(allowedType === "Array" && !allowedArray)
           return allowEmpty || !empty
 
         // Must be an array type specification
@@ -203,16 +204,18 @@ export default class TypeSpec {
     const parts = string.split(delimiter)
 
     this.#specs = parts.map(part => {
-      const typeMatches = /(\w+)(\[\])?/.exec(part)
+      const typeMatches = /^(\w+)(\[\])?$/.exec(part)
 
       if(!typeMatches || typeMatches.length !== 3)
         throw Sass.new(`Invalid type: ${part}`)
 
-      if(!Data.isValidType(typeMatches[1]))
+      const typeName = Util.capitalize(typeMatches[1])
+
+      if(!Data.isValidType(typeName))
         throw Sass.new(`Invalid type: ${typeMatches[1]}`)
 
       return {
-        typeName: typeMatches[1],
+        typeName,
         array: typeMatches[2] === "[]",
       }
     })

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