@gesslar/toolkit 0.8.0 → 1.0.2

package/src/lib/Util.js

@@ -1,88 +1,13 @@
 import {createHash} from "node:crypto"
-import {performance} from "node:perf_hooks"
 import {EventEmitter} from "node:events"
 import Sass from "./Sass.js"
-import Valid from "./Valid.js"
-import Collection from "./Collection.js"
+import {Util as BrowserUtil} from "../browser/index.js"
 
 /**
  * Utility class providing common helper functions for string manipulation,
  * timing, hashing, and option parsing.
  */
-export default class Util {
-  /**
-   * Capitalizes the first letter of a string.
-   *
-   * @param {string} text - The text to capitalize
-   * @returns {string} Text with first letter capitalized
-   */
-  static capitalize(text) {
-    if(typeof text !== "string")
-      throw new TypeError("Util.capitalize expects a string")
-
-    if(text.length === 0)
-      return ""
-
-    const [first, ...rest] = Array.from(text)
-
-    return `${first.toLocaleUpperCase()}${rest.join("")}`
-  }
-
-  /**
-   * Measure wall-clock time for an async function.
-   *
-   * @template T
-   * @param {() => Promise<T>} fn - Thunk returning a promise.
-   * @returns {Promise<{result: T, cost: number}>} Object containing result and elapsed ms (number, 1 decimal).
-   */
-  static async time(fn) {
-    const t0 = performance.now()
-    const result = await fn()
-    const cost = Math.round((performance.now() - t0) * 10) / 10
-
-    return {result, cost}
-  }
-
-  /**
-   * Right-align a string inside a fixed width (left pad with spaces).
-   * If the string exceeds width it is returned unchanged.
-   *
-   * @param {string|number} text - Text to align.
-   * @param {number} width - Target field width (default 80).
-   * @returns {string} Padded string.
-   */
-  static rightAlignText(text, width=80) {
-    const work = String(text)
-
-    if(work.length > width)
-      return work
-
-    const diff = width-work.length
-
-    return `${" ".repeat(diff)}${work}`
-  }
-
-  /**
-   * Centre-align a string inside a fixed width (pad with spaces on left).
-   * If the string exceeds width it is returned unchanged.
-   *
-   * @param {string|number} text - Text to align.
-   * @param {number} width - Target field width (default 80).
-   * @returns {string} Padded string with text centred.
-   */
-  static centreAlignText(text, width=80) {
-    const work = String(text)
-
-    if(work.length >= width)
-      return work
-
-    const totalPadding = width - work.length
-    const leftPadding = Math.floor(totalPadding / 2)
-    const rightPadding = totalPadding - leftPadding
-
-    return `${" ".repeat(leftPadding)}${work}${" ".repeat(rightPadding)}`
-  }
-
+export default class Util extends BrowserUtil {
   /**
    * Compute sha256 hash (hex) of the provided string.
    *
@@ -130,100 +55,6 @@ export default class Util {
       .filter(option => option && /^[a-zA-Z0-9]/.test(option)) // Filter out options that don't start with alphanumeric
   }
 
-  /**
-   * Asynchronously awaits all promises in parallel.
-   * Wrapper around Promise.all for consistency with other utility methods.
-   *
-   * @param {Array<Promise<unknown>>} promises - Array of promises to await
-   * @returns {Promise<Array<unknown>>} Results of all promises
-   */
-  static async awaitAll(promises) {
-    return await Promise.all(promises)
-  }
-
-  /**
-   * Settles all promises (both fulfilled and rejected) in parallel.
-   * Wrapper around Promise.allSettled for consistency with other utility methods.
-   *
-   * @param {Array<Promise<unknown>>} promises - Array of promises to settle
-   * @returns {Promise<Array<object>>} Results of all settled promises with status and value/reason
-   */
-  static async settleAll(promises) {
-    return await Promise.allSettled(promises)
-  }
-
-  /**
-   * Checks if any result in the settled promise array is rejected.
-   *
-   * @param {Array<object>} result - Array of settled promise results.
-   * @returns {boolean} True if any result is rejected, false otherwise.
-   */
-  static anyRejected(result) {
-    return result.some(r => r.status === "rejected")
-  }
-
-  /**
-   * Filters and returns all rejected results from a settled promise array.
-   *
-   * @param {Array<object>} result - Array of settled promise results.
-   * @returns {Array<object>} Array of rejected results.
-   */
-  static settledAndRejected(result) {
-    return result.filter(r => r.status === "rejected")
-  }
-
-  /**
-   * Extracts the rejection reasons from an array of rejected promise results.
-   *
-   * @param {Array<object>} rejected - Array of rejected results.
-   * @returns {Array<unknown>} Array of rejection reasons.
-   */
-  static rejectedReasons(rejected) {
-    return rejected.map(r => r.reason)
-  }
-
-  /**
-   * Throws a Sass error containing all rejection reasons from settled promises.
-   *
-   * @param {string} [_message] - Optional error message. Defaults to "GIGO"
-   * @param {Array<object>} rejected - Array of rejected results.
-   * @throws {Error} Throws a Sass error with rejection reasons.
-   */
-  static throwRejected(_message="GIGO", rejected) {
-    throw Sass.new(Util.rejectedReasons(rejected))
-  }
-
-  /**
-   * Filters and returns all fulfilled results from a settled promise array.
-   *
-   * @param {Array<object>} result - Array of settled promise results.
-   * @returns {Array<object>} Array of fulfilled results.
-   */
-  static settledAndFulfilled(result) {
-    return result.filter(r => r.status === "fulfilled")
-  }
-
-  /**
-   * Extracts the values from all fulfilled results in a settled promise array.
-   *
-   * @param {Array<object>} result - Array of settled promise results.
-   * @returns {Array<unknown>} Array of fulfilled values.
-   */
-  static fulfilledValues(result) {
-    return this.settledAndFulfilled(result).map(r => r.value)
-  }
-
-  /**
-   * Returns the first promise to resolve or reject from an array of promises.
-   * Wrapper around Promise.race for consistency with other utility methods.
-   *
-   * @param {Array<Promise<unknown>>} promises - Array of promises to race
-   * @returns {Promise<unknown>} Result of the first settled promise
-   */
-  static async race(promises) {
-    return await Promise.race(promises)
-  }
-
   /**
    * Private method that performs the actual async emission logic.
    * Handles listener execution, error aggregation, and result processing.
@@ -321,85 +152,4 @@ 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
-  }
-
-  static regexify(input, trim=true, flags=[]) {
-    Valid.type(input, "String")
-    Valid.type(trim, "Boolean")
-    Valid.type(flags, "Array")
-
-    Valid.assert(
-      flags.length === 0 ||
-      (flags.length > 0 && Collection.isArrayUniform(flags, "String")),
-      "All flags must be strings")
-
-    return new RegExp(
-      input
-        .split(/\r\n|\r|\n/)
-        .map(i => trim ? i.trim() : i)
-        .filter(i => trim ? Boolean(i) : true)
-        .join("")
-      , flags?.join(""))
-  }
 }

package/src/lib/Valid.js

@@ -1,20 +1,20 @@
 /**
  * @file Valid.js
  *
- * Provides validation utilities for type checking and assertion.
- * Includes prototype pollution protection for secure object manipulation.
+ * Node-flavoured validation utilities that throw the Node Sass error type.
+ * Mirrors the browser Valid API so browser and Node callers behave the same.
  */
 
-import _assert from "node:assert/strict"
-
 import Sass from "./Sass.js"
-import Data from "./Data.js"
-import Collection from "./Collection.js"
+import Data from "../browser/lib/Data.js"
+import Collection from "../browser/lib/Collection.js"
 
 /**
  * Validation utility class providing type checking and assertion methods.
  */
 export default class Valid {
+  static #restrictedProto = ["__proto__", "constructor", "prototype"]
+
   /**
    * Validates a value against a type. Uses Data.isType.
    *
@@ -40,25 +40,22 @@ export default class Valid {
    *                         met (optional)
    */
   static assert(condition, message, arg = null) {
-    _assert(
-      Data.isType(condition, "boolean"),
-      `Condition must be a boolean, got ${condition}`,
-    )
-    _assert(
-      Data.isType(message, "string"),
-      `Message must be a string, got ${message}`,
-    )
-    _assert(
-      arg === null || arg === undefined || typeof arg === "number",
-      `Arg must be a number, got ${arg}`,
-    )
+    if(!Data.isType(condition, "boolean")) {
+      throw Sass.new(`Condition must be a boolean, got ${condition}`)
+    }
+
+    if(!Data.isType(message, "string")) {
+      throw Sass.new(`Message must be a string, got ${message}`)
+    }
+
+    if(!(arg === null || arg === undefined || typeof arg === "number")) {
+      throw Sass.new(`Arg must be a number, got ${arg}`)
+    }
 
     if(!condition)
       throw Sass.new(`${message}${arg ? `: ${arg}` : ""}`)
   }
 
-  static #restrictedProto = ["__proto__", "constructor", "prototype"]
-
   /**
    * Protects against prototype pollution by checking keys for dangerous property names.
    * Throws if any restricted prototype properties are found in the keys array.

package/src/types/browser/index.d.ts

@@ -0,0 +1,8 @@
+export { default as Collection } from "./lib/Collection.js";
+export { default as Data } from "./lib/Data.js";
+export { default as Sass } from "./lib/Sass.js";
+export { default as Tantrum } from "./lib/Tantrum.js";
+export { default as Type } from "./lib/TypeSpec.js";
+export { default as Util } from "./lib/Util.js";
+export { default as Valid } from "./lib/Valid.js";
+//# sourceMappingURL=index.d.ts.map

package/src/types/browser/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../browser/index.js"],"names":[],"mappings":""}

package/src/types/browser/lib/Collection.d.ts

@@ -0,0 +1,246 @@
+/**
+ * Utility class for collection operations.
+ * Provides static methods for working with arrays, objects, sets, and maps.
+ */
+export default class Collection {
+    /**
+     * Evaluates an array with a predicate function, optionally in reverse order.
+     * Returns the first truthy result from the predicate.
+     *
+     * @param {Array<unknown>} collection - The array to evaluate
+     * @param {(value: unknown, index: number, array: Array<unknown>) => unknown} predicate - Function to evaluate each element
+     * @param {boolean} [forward] - Whether to iterate forward (true) or backward (false). Defaults to true
+     * @returns {unknown|undefined} The first truthy result from the predicate, or undefined
+     * @throws {Sass} If collection is not an array or predicate is not a function
+     */
+    static evalArray(collection: Array<unknown>, predicate: (value: unknown, index: number, array: Array<unknown>) => unknown, forward?: boolean): unknown | undefined;
+    /**
+     * Evaluates an object with a predicate function.
+     * Returns the first truthy result from the predicate.
+     *
+     * @param {object} collection - The object to evaluate
+     * @param {(value: unknown, key: string, object: object) => unknown} predicate - Function to evaluate each property
+     * @returns {unknown|undefined} The first truthy result from the predicate, or undefined
+     * @throws {Sass} If collection is not an object or predicate is not a function
+     */
+    static evalObject(collection: object, predicate: (value: unknown, key: string, object: object) => unknown): unknown | undefined;
+    /**
+     * Evaluates a Set with a predicate function.
+     * Returns the first truthy result from the predicate.
+     *
+     * @param {Set<unknown>} collection - The Set to evaluate
+     * @param {(value: unknown, set: Set<unknown>) => unknown} predicate - Function to evaluate each element
+     * @returns {unknown|undefined} The first truthy result from the predicate, or undefined
+     * @throws {Sass} If collection is not a Set or predicate is not a function
+     */
+    static evalSet(collection: Set<unknown>, predicate: (value: unknown, set: Set<unknown>) => unknown): unknown | undefined;
+    /**
+     * Evaluates a Map with a predicate function, optionally in reverse order.
+     * Returns the first truthy result from the predicate.
+     *
+     * @param {Map<unknown, unknown>} collection - The Map to evaluate
+     * @param {(value: unknown, key: unknown, map: Map<unknown, unknown>) => unknown} predicate - Function to evaluate each entry
+     * @param {boolean} [forward] - Whether to iterate forward (true) or backward (false). Defaults to true
+     * @returns {unknown|undefined} The first truthy result from the predicate, or undefined
+     * @throws {Sass} If collection is not a Map or predicate is not a function
+     */
+    static evalMap(collection: Map<unknown, unknown>, predicate: (value: unknown, key: unknown, map: Map<unknown, unknown>) => unknown, forward?: boolean): unknown | undefined;
+    /**
+     * Zips two arrays together into an array of pairs.
+     * The resulting array length equals the shorter input array.
+     *
+     * @param {Array<unknown>} array1 - The first array
+     * @param {Array<unknown>} array2 - The second array
+     * @returns {Array<[unknown, unknown]>} Array of paired elements
+     */
+    static zip(array1: Array<unknown>, array2: Array<unknown>): Array<[unknown, unknown]>;
+    /**
+     * Unzips an array of pairs into separate arrays.
+     * Transposes a 2D array structure.
+     *
+     * @param {Array<Array<unknown>>} array - Array of arrays to unzip
+     * @returns {Array<Array<unknown>>} Array of unzipped arrays, or empty array for invalid input
+     */
+    static unzip(array: Array<Array<unknown>>): Array<Array<unknown>>;
+    /**
+     * Maps an array using an async function, processing items sequentially.
+     * Unlike Promise.all(array.map()), this processes one item at a time.
+     *
+     * @param {Array<unknown>} array - The array to map
+     * @param {(item: unknown) => Promise<unknown>} asyncFn - Async function to apply to each element
+     * @returns {Promise<Array<unknown>>} Promise resolving to the mapped array
+     * @throws {Sass} If array is not an Array or asyncFn is not a function
+     */
+    static asyncMap(array: Array<unknown>, asyncFn: (item: unknown) => Promise<unknown>): Promise<Array<unknown>>;
+    /**
+     * Checks if all elements in an array are of a specified type
+     *
+     * @param {Array<unknown>} arr - The array to check
+     * @param {string} [type] - The type to check for (optional, defaults to the type of the first element)
+     * @returns {boolean} Whether all elements are of the specified type
+     */
+    static isArrayUniform(arr: Array<unknown>, type?: string): boolean;
+    /**
+     * Checks if an array is unique
+     *
+     * @param {Array<unknown>} arr - The array of which to remove duplicates
+     * @returns {Array<unknown>} The unique elements of the array
+     */
+    static isArrayUnique(arr: Array<unknown>): Array<unknown>;
+    /**
+     * Returns the intersection of two arrays.
+     *
+     * @param {Array<unknown>} arr1 - The first array.
+     * @param {Array<unknown>} arr2 - The second array.
+     * @returns {Array<unknown>} The intersection of the two arrays.
+     */
+    static intersection(arr1: Array<unknown>, arr2: Array<unknown>): Array<unknown>;
+    /**
+     * Checks whether two arrays have any elements in common.
+     *
+     * This function returns `true` if at least one element from `arr1` exists in
+     * `arr2`, and `false` otherwise. It optimizes by iterating over the shorter
+     * array for efficiency.
+     *
+     * Example:
+     *   Collection.intersects([1, 2, 3], [3, 4, 5]) // returns true
+     *   Collection.intersects(["a", "b"], ["c", "d"]) // returns false
+     *
+     * @param {Array<unknown>} arr1 - The first array to check for intersection.
+     * @param {Array<unknown>} arr2 - The second array to check for intersection.
+     * @returns {boolean} True if any element is shared between the arrays, false otherwise.
+     */
+    static intersects(arr1: Array<unknown>, arr2: Array<unknown>): boolean;
+    /**
+     * Pads an array to a specified length with a value. This operation
+     * occurs in-place.
+     *
+     * @param {Array<unknown>} arr - The array to pad.
+     * @param {number} length - The length to pad the array to.
+     * @param {unknown} value - The value to pad the array with.
+     * @param {number} [position] - The position to pad the array at. Defaults to 0
+     * @returns {Array<unknown>} The padded array.
+     */
+    static arrayPad(arr: Array<unknown>, length: number, value: unknown, position?: number): Array<unknown>;
+    /**
+     * Filters an array asynchronously using a predicate function.
+     * Applies the predicate to all items in parallel and returns filtered results.
+     *
+     * @param {Array<unknown>} arr - The array to filter
+     * @param {(value: unknown, index: number, array: Array<unknown>) => Promise<boolean>} predicate - Async predicate function that returns a promise resolving to boolean
+     * @returns {Promise<Array<unknown>>} Promise resolving to the filtered array
+     */
+    static asyncFilter(arr: Array<unknown>, predicate: (value: unknown, index: number, array: Array<unknown>) => Promise<boolean>): Promise<Array<unknown>>;
+    /**
+     * Clones an object
+     *
+     * @param {object} obj - The object to clone
+     * @param {boolean} freeze - Whether to freeze the cloned object
+     * @returns {object} The cloned object
+     */
+    static cloneObject(obj: object, freeze?: boolean): object;
+    /**
+     * Checks if an object is empty
+     *
+     * @param {object} obj - The object to check
+     * @returns {boolean} Whether the object is empty
+     */
+    static isObjectEmpty(obj: object): boolean;
+    /**
+     * Ensures that a nested path of objects exists within the given object.
+     * Creates empty objects along the path if they don't exist.
+     *
+     * @param {object} obj - The object to check/modify
+     * @param {Array<string>} keys - Array of keys representing the path to ensure
+     * @returns {object} Reference to the deepest nested object in the path
+     */
+    static assureObjectPath(obj: object, keys: Array<string>): object;
+    /**
+     * Sets a value in a nested object structure using an array of keys; creating
+     * the structure if it does not exist.
+     *
+     * @param {object} obj - The target object to set the value in
+     * @param {Array<string>} keys - Array of keys representing the path to the target property
+     * @param {unknown} value - The value to set at the target location
+     */
+    static setNestedValue(obj: object, keys: Array<string>, value: unknown): void;
+    /**
+     * Deeply merges two or more objects. Arrays are replaced, not merged.
+     *
+     * @param {...object} sources - Objects to merge (left to right)
+     * @returns {object} The merged object
+     */
+    static mergeObject(...sources: object[]): object;
+    /**
+     * Freezes an object and all of its properties recursively.
+     *
+     * @param {object} obj The object to freeze.
+     * @returns {object} The frozen object.
+     */
+    static deepFreezeObject(obj: object): object;
+    /**
+     * Maps an object using a transformer function
+     *
+     * @param {object} original The original object
+     * @param {function(unknown): unknown} transformer The transformer function
+     * @param {boolean} mutate Whether to mutate the original object
+     * @returns {Promise<object>} The mapped object
+     */
+    static mapObject(original: object, transformer: (arg0: unknown) => unknown, mutate?: boolean): Promise<object>;
+    /**
+     * Allocates an object from a source array and a spec array or function.
+     *
+     * @param {unknown} source The source array
+     * @param {Array<unknown>|function(Array<unknown>): Promise<Array<unknown>>|Array<unknown>} spec The spec array or function
+     * @returns {Promise<object>} The allocated object
+     */
+    static allocateObject(source: unknown, spec: Array<unknown> | ((arg0: Array<unknown>) => Promise<Array<unknown>> | Array<unknown>)): Promise<object>;
+    /**
+     * Trims falsy values from both ends of an array (in-place).
+     * Optionally preserves specific falsy values.
+     *
+     * @param {Array<unknown>} arr - The array to trim
+     * @param {Array<unknown>} [except] - Values to preserve even if falsy. Defaults to empty array
+     * @returns {Array<unknown>} The trimmed array (same reference, modified in-place)
+     * @throws {Sass} If arr is not an Array or except is not an Array
+     */
+    static trimArray(arr: Array<unknown>, except?: Array<unknown>): Array<unknown>;
+    /**
+     * Trims falsy values from the right end of an array (in-place).
+     * Optionally preserves specific falsy values.
+     *
+     * @param {Array<unknown>} arr - The array to trim
+     * @param {Array<unknown>} [except] - Values to preserve even if falsy. Defaults to empty array
+     * @returns {Array<unknown>} The trimmed array (same reference, modified in-place)
+     * @throws {Sass} If arr is not an Array or except is not an Array
+     */
+    static trimArrayRight(arr: Array<unknown>, except?: Array<unknown>): Array<unknown>;
+    /**
+     * Trims falsy values from the left end of an array (in-place).
+     * Optionally preserves specific falsy values.
+     *
+     * @param {Array<unknown>} arr - The array to trim
+     * @param {Array<unknown>} [except] - Values to preserve even if falsy. Defaults to empty array
+     * @returns {Array<unknown>} The trimmed array (same reference, modified in-place)
+     * @throws {Sass} If arr is not an Array or except is not an Array
+     */
+    static trimArrayLeft(arr: Array<unknown>, except?: Array<unknown>): Array<unknown>;
+    /**
+     * Transposes an array of objects into an object of arrays.
+     * Collects values for each key across all objects into arrays.
+     *
+     * @param {Array<object>} objects - Array of plain objects to transpose
+     * @returns {object} Object with keys from input objects, values as arrays
+     * @throws {Sass} If objects is not an Array or contains non-plain objects
+     */
+    static transposeObjects(objects: Array<object>): object;
+    /**
+     * Flattens an array (or nested array) of objects and transposes them.
+     * Combines flat() and transposeObjects() operations.
+     *
+     * @param {Array<object>|Array<Array<object>>} input - Array or nested array of objects
+     * @returns {object} Transposed object with arrays of values
+     */
+    static flattenObjectArray(input: Array<object> | Array<Array<object>>): object;
+}
+//# sourceMappingURL=Collection.d.ts.map

package/src/types/browser/lib/Collection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Collection.d.ts","sourceRoot":"","sources":["../../../browser/lib/Collection.js"],"names":[],"mappings":"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"}