@gesslar/toolkit 3.9.0 → 3.12.3

package/package.json

@@ -5,7 +5,7 @@
     "name": "gesslar",
     "url": "https://gesslar.dev"
   },
-  "version": "3.9.0",
+  "version": "3.12.3",
   "license": "Unlicense",
   "homepage": "https://github.com/gesslar/toolkit#readme",
   "repository": {
@@ -53,12 +53,11 @@
   "dependencies": {
     "@gesslar/colours": "^0.7.1",
     "ajv": "^8.17.1",
-    "globby": "^16.1.0",
     "json5": "^2.2.3",
     "yaml": "^2.8.2"
   },
   "devDependencies": {
-    "@gesslar/uglier": "^0.5.1",
+    "@gesslar/uglier": "^0.6.0",
     "eslint": "^9.39.2",
     "happy-dom": "^20.0.11",
     "typescript": "^5.9.3"
@@ -70,6 +69,7 @@
     "submit": "pnpm publish --access public --//registry.npmjs.org/:_authToken=\"${NPM_ACCESS_TOKEN}\"",
     "update": "pnpm up --latest --recursive",
     "test": "node --test tests/**/*.test.js",
+    "test:coverage": "node --experimental-config-file=node.config.json --experimental-test-coverage --test-timeout=3000 --test tests/**/*.test.js",
     "test:node": "node --test tests/node/*.test.js",
     "test:browser": "node --test tests/browser/*.test.js",
     "pr": "gt submit -p --ai",

package/src/browser/lib/Data.js

@@ -75,7 +75,7 @@ export default class Data {
    *
    * @type {Array<string>}
    */
-  static emptyableTypes = Object.freeze(["String", "Array", "Object"])
+  static emptyableTypes = Object.freeze(["String", "Array", "Object", "Map", "Set"])
 
   /**
    * Appends a string to another string if it does not already end with it.
@@ -84,8 +84,10 @@ export default class Data {
    * @param {string} append - The string to append
    * @returns {string} The appended string
    */
-  static appendString(string, append) {
-    return string.endsWith(append) ? string : `${string}${append}`
+  static append(string, append) {
+    return string.endsWith(append)
+      ? string :
+      `${string}${append}`
   }
 
   /**
@@ -95,8 +97,87 @@ export default class Data {
    * @param {string} prepend - The string to prepend
    * @returns {string} The prepended string
    */
-  static prependString(string, prepend) {
-    return string.startsWith(prepend) ? string : `${prepend}${string}`
+  static prepend(string, prepend) {
+    return string.startsWith(prepend)
+      ? string
+      : `${prepend}${string}`
+  }
+
+  /**
+   * Remove a suffix from the end of a string if present.
+   *
+   * @param {string} string - The string to process
+   * @param {string} toChop - The suffix to remove from the end
+   * @param {boolean} [caseInsensitive=false] - Whether to perform case-insensitive matching
+   * @returns {string} The string with suffix removed, or original if suffix not found
+   * @example
+   * Data.chopRight("hello.txt", ".txt") // "hello"
+   * Data.chopRight("Hello", "o") // "Hell"
+   * Data.chopRight("HELLO", "lo", true) // "HEL"
+   */
+  static chopRight(string, toChop, caseInsensitive=false) {
+    const escaped = toChop.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")
+    const regex = new RegExp(`${escaped}$`, caseInsensitive === true ? "i" : "")
+
+    return string.replace(regex, "")
+  }
+
+  /**
+   * Remove a prefix from the beginning of a string if present.
+   *
+   * @param {string} string - The string to process
+   * @param {string} toChop - The prefix to remove from the beginning
+   * @param {boolean} [caseInsensitive=false] - Whether to perform case-insensitive matching
+   * @returns {string} The string with prefix removed, or original if prefix not found
+   * @example
+   * Data.chopLeft("hello.txt", "hello") // ".txt"
+   * Data.chopLeft("Hello", "H") // "ello"
+   * Data.chopLeft("HELLO", "he", true) // "LLO"
+   */
+  static chopLeft(string, toChop, caseInsensitive=false) {
+    const escaped = toChop.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")
+    const regex = new RegExp(`^${escaped}`, caseInsensitive === true ? "i" : "")
+
+    return string.replace(regex, "")
+  }
+
+  /**
+   * Chop a string after the first occurence of another string.
+   *
+   * @param {string} string - The string to search
+   * @param {string} needle - The bit to chop after
+   * @param {boolean} caseInsensitive - Whether to search insensitive to case
+   * @returns {string} The remaining string
+   */
+  static chopAfter(string, needle, caseInsensitive=false) {
+    const escaped = needle.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")
+    const regex = new RegExp(`${escaped}`, caseInsensitive === true ? "i" : "")
+    const index = string.search(regex)
+
+    if(index === -1)
+      return string
+
+    return string.slice(0, index)
+  }
+
+  /**
+   * Chop a string before the first occurrence of another string.
+   *
+   * @param {string} string - The string to search
+   * @param {string} needle - The bit to chop before
+   * @param {boolean} caseInsensitive - Whether to search insensitive to case
+   * @returns {string} The remaining string
+   */
+  static chopBefore(string, needle, caseInsensitive=false) {
+    const escaped = needle.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")
+    const regex = new RegExp(`${escaped}`, caseInsensitive === true ? "i" : "")
+    const length = needle.length
+    const index = string.search(regex)
+
+    if(index === -1)
+      return string
+
+    return string.slice(index + length)
   }
 
   /**
@@ -236,6 +317,9 @@ export default class Data {
         return Object.keys(value).length === 0
       case "String":
         return value.trim().length === 0
+      case "Map":
+      case "Set":
+        return value.size === 0
       default:
         return false
     }

package/src/browser/lib/TypeSpec.js

@@ -144,7 +144,6 @@ export default class TypeSpec {
 
   match(value, options) {
     const allowEmpty = options?.allowEmpty ?? true
-    const empty = Data.isEmpty(value)
 
     // If we have a list of types, because the string was validly parsed, we
     // need to ensure that all of the types that were parsed are valid types in
@@ -161,6 +160,9 @@ export default class TypeSpec {
     // types in an array, if it is an array and an array is allowed.
     const matchingTypeSpec = this.filter(spec => {
       const {typeName: allowedType, array: allowedArray} = spec
+      const empty =
+        Data.emptyableTypes.includes(allowedType) &&
+        Data.isEmpty(value)
 
       // Handle non-array values
       if(!isArray && !allowedArray) {