@quenty/string 3.3.7 → 3.4.1

package/CHANGELOG.md

@@ -3,6 +3,16 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [3.4.1](https://github.com/Quenty/NevermoreEngine/compare/@quenty/string@3.4.0...@quenty/string@3.4.1) (2026-08-14)
+
+**Note:** Version bump only for package @quenty/string
+
+# [3.4.0](https://github.com/Quenty/NevermoreEngine/compare/@quenty/string@3.3.7...@quenty/string@3.4.0) (2026-07-23)
+
+### Features
+
+- Add unit tests to string package ([f15f2f2](https://github.com/Quenty/NevermoreEngine/commit/f15f2f2892d782bed552a882e31f3b5d07975184))
+
 ## [3.3.7](https://github.com/Quenty/NevermoreEngine/compare/@quenty/string@3.3.6...@quenty/string@3.3.7) (2026-05-30)
 
 **Note:** Version bump only for package @quenty/string

package/deploy.nevermore.json

@@ -0,0 +1,10 @@
+{
+  "targets": {
+    "test": {
+      "universeId": 9716264427,
+      "placeId": 100668032156705,
+      "project": "test/default.project.json",
+      "scriptTemplate": "test/scripts/Server/ServerMain.server.lua"
+    }
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@quenty/string",
-  "version": "3.3.7",
+  "version": "3.4.1",
   "description": "This module provides utility functions for strings",
   "keywords": [
     "Roblox",
@@ -25,11 +25,16 @@
   "scripts": {
     "preinstall": "npx only-allow pnpm"
   },
+  "dependencies": {
+    "@quenty/loader": "10.11.1",
+    "@quenty/nevermore-test-runner": "1.5.1",
+    "@quentystudios/jest-lua": "3.10.0-quenty.2"
+  },
   "contributors": [
     "Quenty"
   ],
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "598b2b62b36bdcbdbbd56f7db10c399831cc6eba"
+  "gitHead": "f084360c3729ea424d49d9bc42f8f0d1c128fa82"
 }

package/src/Shared/String.lua

@@ -102,10 +102,10 @@ end
 
 --[=[
 	Checks if a string is empty or nil
-	@param str string
+	@param str string?
 	@return boolean
 ]=]
-function String.isEmptyOrWhitespaceOrNil(str: string): boolean
+function String.isEmptyOrWhitespaceOrNil(str: string?): boolean
 	return type(str) ~= "string" or str == "" or String.isWhitespace(str)
 end
 

package/src/Shared/String.spec.lua

@@ -0,0 +1,235 @@
+--!strict
+--[[
+	@class String.spec.lua
+]]
+
+local require = require(script.Parent.loader).load(script)
+
+local Jest = require("Jest")
+local String = require("String")
+
+local describe = Jest.Globals.describe
+local expect = Jest.Globals.expect
+local it = Jest.Globals.it
+
+describe("String.trim", function()
+	it("trims leading and trailing whitespace by default", function()
+		expect(String.trim("  hello  ")).toEqual("hello")
+	end)
+
+	it("trims tabs and newlines", function()
+		expect(String.trim("\t\nhello world\n\t")).toEqual("hello world")
+	end)
+
+	it("leaves interior whitespace untouched", function()
+		expect(String.trim("  a  b  ")).toEqual("a  b")
+	end)
+
+	it("returns an empty string for all-whitespace input", function()
+		expect(String.trim("   ")).toEqual("")
+	end)
+
+	it("is a no-op when there is nothing to trim", function()
+		expect(String.trim("hello")).toEqual("hello")
+	end)
+
+	it("trims a custom pattern", function()
+		expect(String.trim("xxhelloxx", "x")).toEqual("hello")
+	end)
+end)
+
+describe("String.trimFront", function()
+	it("trims only the leading whitespace by default", function()
+		expect(String.trimFront("  hello  ")).toEqual("hello  ")
+	end)
+
+	it("leaves a string without a leading match untouched", function()
+		expect(String.trimFront("hello  ")).toEqual("hello  ")
+	end)
+
+	it("trims a custom leading pattern", function()
+		expect(String.trimFront("xxhello", "x")).toEqual("hello")
+	end)
+end)
+
+describe("String.toCamelCase", function()
+	it("converts snake_case to UpperCamelCase", function()
+		expect(String.toCamelCase("hello_world")).toEqual("HelloWorld")
+	end)
+
+	it("converts YELL_CASE to UpperCamelCase", function()
+		expect(String.toCamelCase("YELL_CASE")).toEqual("YellCase")
+	end)
+
+	it("converts space separated words to UpperCamelCase", function()
+		expect(String.toCamelCase("hello world")).toEqual("HelloWorld")
+	end)
+
+	it("capitalizes the first letter of a single lowercase word", function()
+		expect(String.toCamelCase("hello")).toEqual("Hello")
+	end)
+
+	it("strips remaining punctuation", function()
+		expect(String.toCamelCase("foo-bar")).toEqual("Foobar")
+	end)
+end)
+
+describe("String.toLowerCamelCase", function()
+	it("converts snake_case to lowerCamelCase", function()
+		expect(String.toLowerCamelCase("hello_world")).toEqual("helloWorld")
+	end)
+
+	it("converts YELL_CASE to lowerCamelCase", function()
+		expect(String.toLowerCamelCase("YELL_CASE")).toEqual("yellCase")
+	end)
+
+	it("keeps the first letter lowercase", function()
+		expect(String.toLowerCamelCase("hello")).toEqual("hello")
+	end)
+end)
+
+describe("String.uppercaseFirstLetter", function()
+	it("uppercases the first letter", function()
+		expect(String.uppercaseFirstLetter("hello")).toEqual("Hello")
+	end)
+
+	it("leaves an already-uppercase first letter untouched", function()
+		expect(String.uppercaseFirstLetter("Hello")).toEqual("Hello")
+	end)
+
+	it("is a no-op when the first character is not a letter", function()
+		expect(String.uppercaseFirstLetter("123abc")).toEqual("123abc")
+	end)
+end)
+
+describe("String.toPrivateCase", function()
+	it("prefixes with an underscore and lowercases the first letter", function()
+		expect(String.toPrivateCase("MyThing")).toEqual("_myThing")
+	end)
+
+	it("preserves the remainder of the string", function()
+		expect(String.toPrivateCase("SomeValue")).toEqual("_someValue")
+	end)
+end)
+
+describe("String.checkNumOfCharacterInString", function()
+	it("counts the occurrences of a character", function()
+		expect(String.checkNumOfCharacterInString("hello", "l")).toEqual(2)
+	end)
+
+	it("returns 0 when the character is absent", function()
+		expect(String.checkNumOfCharacterInString("hello", "z")).toEqual(0)
+	end)
+
+	it("counts every character in the string", function()
+		expect(String.checkNumOfCharacterInString("aaaa", "a")).toEqual(4)
+	end)
+end)
+
+describe("String.isWhitespace", function()
+	it("returns true for a string of only whitespace", function()
+		expect(String.isWhitespace("   ")).toEqual(true)
+	end)
+
+	it("returns false for a string with non-whitespace", function()
+		expect(String.isWhitespace("a b")).toEqual(false)
+	end)
+
+	it("returns false for an empty string", function()
+		expect(String.isWhitespace("")).toEqual(false)
+	end)
+end)
+
+describe("String.isEmptyOrWhitespaceOrNil", function()
+	it("returns true for nil", function()
+		expect(String.isEmptyOrWhitespaceOrNil(nil)).toEqual(true)
+	end)
+
+	it("returns true for an empty string", function()
+		expect(String.isEmptyOrWhitespaceOrNil("")).toEqual(true)
+	end)
+
+	it("returns true for a whitespace-only string", function()
+		expect(String.isEmptyOrWhitespaceOrNil("  \t")).toEqual(true)
+	end)
+
+	it("returns false for a string with content", function()
+		expect(String.isEmptyOrWhitespaceOrNil("hello")).toEqual(false)
+	end)
+end)
+
+describe("String.elipseLimit", function()
+	it("truncates and appends an ellipsis when over the limit", function()
+		expect(String.elipseLimit("hello world", 8)).toEqual("hello...")
+	end)
+
+	it("leaves a string at or under the limit untouched", function()
+		expect(String.elipseLimit("hello", 8)).toEqual("hello")
+	end)
+
+	it("produces a result of exactly the limit length", function()
+		expect(#String.elipseLimit("abcdefghij", 8)).toEqual(8)
+	end)
+end)
+
+describe("String.removePrefix", function()
+	it("removes a matching prefix", function()
+		expect(String.removePrefix("foobar", "foo")).toEqual("bar")
+	end)
+
+	it("returns the string unchanged when the prefix does not match", function()
+		expect(String.removePrefix("foobar", "xyz")).toEqual("foobar")
+	end)
+end)
+
+describe("String.removePostfix", function()
+	it("removes a matching postfix", function()
+		expect(String.removePostfix("foobar", "bar")).toEqual("foo")
+	end)
+
+	it("returns the string unchanged when the postfix does not match", function()
+		expect(String.removePostfix("foobar", "xyz")).toEqual("foobar")
+	end)
+end)
+
+describe("String.startsWith", function()
+	it("returns true when the string starts with the prefix", function()
+		expect(String.startsWith("foobar", "foo")).toEqual(true)
+	end)
+
+	it("returns false when the string does not start with the prefix", function()
+		expect(String.startsWith("foobar", "bar")).toEqual(false)
+	end)
+end)
+
+describe("String.endsWith", function()
+	it("returns true when the string ends with the postfix", function()
+		expect(String.endsWith("foobar", "bar")).toEqual(true)
+	end)
+
+	it("returns false when the string does not end with the postfix", function()
+		expect(String.endsWith("foobar", "foo")).toEqual(false)
+	end)
+end)
+
+describe("String.addCommas", function()
+	it("adds commas to a large number", function()
+		expect(String.addCommas(1000000)).toEqual("1,000,000")
+	end)
+
+	it("leaves numbers under a thousand unchanged", function()
+		expect(String.addCommas(123)).toEqual("123")
+	end)
+
+	it("handles negative numbers", function()
+		expect(String.addCommas(-1234567)).toEqual("-1,234,567")
+	end)
+
+	it("accepts a string number", function()
+		expect(String.addCommas("1234567")).toEqual("1,234,567")
+	end)
+
+	it("uses a custom separator", function()
+		expect(String.addCommas(1234, ".")).toEqual("1.234")
+	end)
+end)

package/src/jest.config.lua

@@ -0,0 +1,3 @@
+return {
+	testMatch = { "**/*.spec" },
+}

package/src/node_modules.project.json

@@ -0,0 +1,7 @@
+{
+  "name": "node_modules",
+  "globIgnorePaths": [ "**/.package-lock.json" ],
+  "tree": {
+    "$path": { "optional": "../node_modules" }
+  }
+}

package/test/default.project.json

@@ -0,0 +1,25 @@
+{
+  "name": "StringTest",
+  "globIgnorePaths": [
+    "**/.package-lock.json",
+    "**/.pnpm",
+    "**/.pnpm-workspace-state-v1.json",
+    "**/.modules.yaml",
+    "**/.ignored",
+    "**/.ignored_*"
+  ],
+  "tree": {
+    "$className": "DataModel",
+    "ServerScriptService": {
+      "$properties": {
+        "LoadStringEnabled": true
+      },
+      "string": {
+        "$path": ".."
+      },
+      "Script": {
+        "$path": "scripts/Server"
+      }
+    }
+  }
+}

package/test/scripts/Server/ServerMain.server.lua

@@ -0,0 +1,14 @@
+--!nonstrict
+--[[
+	@class ServerMain
+]]
+
+local ServerScriptService = game:GetService("ServerScriptService")
+
+local root = ServerScriptService.string
+local loader = root:FindFirstChild("LoaderUtils", true).Parent
+local require = require(loader).bootstrapGame(root)
+
+local NevermoreTestRunnerUtils = require("NevermoreTestRunnerUtils")
+
+NevermoreTestRunnerUtils.runTestsIfNeededAsync(root)