test: add explicit unit tests for string utility functions

Add comprehensive test coverage for string utility functions that were previously only tested indirectly through integration tests. These explicit unit tests improve maintainability and documentation.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <[email protected]>

Author: jdalton

test/strings.test.mts

@@ -0,0 +1,305 @@
+import { describe, expect, it } from 'vitest'
+
+import {
+  isBlank,
+  isNonEmptyString,
+  isSemverString,
+  localeCompare,
+  lowerName,
+  lowerNamespace,
+  lowerVersion,
+  replaceDashesWithUnderscores,
+  replaceUnderscoresWithDashes,
+  trimLeadingSlashes,
+} from '../src/strings.js'
+
+describe('String utilities', () => {
+  describe('isBlank', () => {
+    it('should return true for empty string', () => {
+      expect(isBlank('')).toBe(true)
+    })
+
+    it('should return true for string with only spaces', () => {
+      expect(isBlank('   ')).toBe(true)
+    })
+
+    it('should return true for string with only tabs', () => {
+      expect(isBlank('\t\t\t')).toBe(true)
+    })
+
+    it('should return true for string with various whitespace characters', () => {
+      // Space, Tab, Line Feed, Vertical Tab, Form Feed, Carriage Return
+      expect(isBlank(' \t\n\v\f\r')).toBe(true)
+    })
+
+    it('should return true for No-Break Space (U+00A0)', () => {
+      expect(isBlank('\u00a0')).toBe(true)
+    })
+
+    it('should return true for Ogham Space Mark (U+1680)', () => {
+      expect(isBlank('\u1680')).toBe(true)
+    })
+
+    it('should return true for various Em/En spaces (U+2000-U+200A)', () => {
+      expect(isBlank('\u2000\u2001\u2002\u2003\u2004')).toBe(true)
+      expect(isBlank('\u2005\u2006\u2007\u2008\u2009\u200a')).toBe(true)
+    })
+
+    it('should return true for Line/Paragraph Separators (U+2028, U+2029)', () => {
+      expect(isBlank('\u2028\u2029')).toBe(true)
+    })
+
+    it('should return true for Narrow No-Break Space (U+202F)', () => {
+      expect(isBlank('\u202f')).toBe(true)
+    })
+
+    it('should return true for Medium Mathematical Space (U+205F)', () => {
+      expect(isBlank('\u205f')).toBe(true)
+    })
+
+    it('should return true for Ideographic Space (U+3000)', () => {
+      expect(isBlank('\u3000')).toBe(true)
+    })
+
+    it('should return true for Byte Order Mark (U+FEFF)', () => {
+      expect(isBlank('\ufeff')).toBe(true)
+    })
+
+    it('should return false for non-whitespace characters', () => {
+      expect(isBlank('a')).toBe(false)
+      expect(isBlank(' a ')).toBe(false)
+      expect(isBlank('  text  ')).toBe(false)
+    })
+
+    it('should return false for string with mixed whitespace and non-whitespace', () => {
+      expect(isBlank('\t \n test \r\n')).toBe(false)
+    })
+  })
+
+  describe('isNonEmptyString', () => {
+    it('should return true for non-empty strings', () => {
+      expect(isNonEmptyString('test')).toBe(true)
+      expect(isNonEmptyString(' ')).toBe(true)
+      expect(isNonEmptyString('a')).toBe(true)
+    })
+
+    it('should return false for empty string', () => {
+      expect(isNonEmptyString('')).toBe(false)
+    })
+
+    it('should return false for non-string values', () => {
+      expect(isNonEmptyString(null)).toBe(false)
+      expect(isNonEmptyString(undefined)).toBe(false)
+      expect(isNonEmptyString(123)).toBe(false)
+      expect(isNonEmptyString({})).toBe(false)
+      expect(isNonEmptyString([])).toBe(false)
+    })
+  })
+
+  describe('isSemverString', () => {
+    it('should return true for valid semver strings', () => {
+      expect(isSemverString('1.0.0')).toBe(true)
+      expect(isSemverString('0.0.0')).toBe(true)
+      expect(isSemverString('1.2.3')).toBe(true)
+      expect(isSemverString('10.20.30')).toBe(true)
+    })
+
+    it('should return true for semver with prerelease', () => {
+      expect(isSemverString('1.0.0-alpha')).toBe(true)
+      expect(isSemverString('1.0.0-alpha.1')).toBe(true)
+      expect(isSemverString('1.0.0-0.3.7')).toBe(true)
+      expect(isSemverString('1.0.0-x.7.z.92')).toBe(true)
+    })
+
+    it('should return true for semver with build metadata', () => {
+      expect(isSemverString('1.0.0+20130313144700')).toBe(true)
+      expect(isSemverString('1.0.0+exp.sha.5114f85')).toBe(true)
+    })
+
+    it('should return true for semver with prerelease and build metadata', () => {
+      expect(isSemverString('1.0.0-beta+exp.sha.5114f85')).toBe(true)
+      expect(isSemverString('1.0.0-alpha.1+001')).toBe(true)
+    })
+
+    it('should return false for invalid semver strings', () => {
+      expect(isSemverString('1')).toBe(false)
+      expect(isSemverString('1.2')).toBe(false)
+      expect(isSemverString('1.2.3.4')).toBe(false)
+      expect(isSemverString('v1.2.3')).toBe(false)
+      // Leading zeros not allowed
+      expect(isSemverString('01.2.3')).toBe(false)
+    })
+
+    it('should return false for non-string values', () => {
+      expect(isSemverString(null)).toBe(false)
+      expect(isSemverString(undefined)).toBe(false)
+      expect(isSemverString(123)).toBe(false)
+    })
+  })
+
+  describe('localeCompare', () => {
+    it('should compare strings correctly', () => {
+      expect(localeCompare('a', 'b')).toBeLessThan(0)
+      expect(localeCompare('b', 'a')).toBeGreaterThan(0)
+      expect(localeCompare('a', 'a')).toBe(0)
+    })
+
+    it('should handle case-insensitive comparison', () => {
+      const result = localeCompare('A', 'a')
+      // Result depends on locale, but should be consistent
+      expect(typeof result).toBe('number')
+    })
+
+    it('should reuse Intl.Collator instance on subsequent calls', () => {
+      // First call initializes the collator
+      const result1 = localeCompare('test1', 'test2')
+      // Second call reuses the collator
+      const result2 = localeCompare('test1', 'test2')
+      expect(result1).toBe(result2)
+    })
+  })
+
+  describe('lowerName', () => {
+    it('should convert name to lowercase', () => {
+      const purl = { name: 'MyPackage' }
+      lowerName(purl)
+      expect(purl.name).toBe('mypackage')
+    })
+
+    it('should handle already lowercase name', () => {
+      const purl = { name: 'mypackage' }
+      lowerName(purl)
+      expect(purl.name).toBe('mypackage')
+    })
+
+    it('should handle mixed case names', () => {
+      const purl = { name: 'My-Package_Name' }
+      lowerName(purl)
+      expect(purl.name).toBe('my-package_name')
+    })
+  })
+
+  describe('lowerNamespace', () => {
+    it('should convert namespace to lowercase', () => {
+      const purl = { namespace: 'MyNamespace' }
+      lowerNamespace(purl)
+      expect(purl.namespace).toBe('mynamespace')
+    })
+
+    it('should handle undefined namespace', () => {
+      const purl: { namespace?: string } = {}
+      lowerNamespace(purl)
+      expect(purl.namespace).toBeUndefined()
+    })
+
+    it('should handle already lowercase namespace', () => {
+      const purl = { namespace: 'mynamespace' }
+      lowerNamespace(purl)
+      expect(purl.namespace).toBe('mynamespace')
+    })
+  })
+
+  describe('lowerVersion', () => {
+    it('should convert version to lowercase', () => {
+      const purl = { version: '1.0.0-BETA' }
+      lowerVersion(purl)
+      expect(purl.version).toBe('1.0.0-beta')
+    })
+
+    it('should handle undefined version', () => {
+      const purl: { version?: string } = {}
+      lowerVersion(purl)
+      expect(purl.version).toBeUndefined()
+    })
+
+    it('should handle already lowercase version', () => {
+      const purl = { version: '1.0.0-alpha' }
+      lowerVersion(purl)
+      expect(purl.version).toBe('1.0.0-alpha')
+    })
+  })
+
+  describe('replaceDashesWithUnderscores', () => {
+    it('should replace all dashes with underscores', () => {
+      expect(replaceDashesWithUnderscores('my-package-name')).toBe(
+        'my_package_name',
+      )
+    })
+
+    it('should handle string without dashes', () => {
+      expect(replaceDashesWithUnderscores('mypackage')).toBe('mypackage')
+    })
+
+    it('should handle empty string', () => {
+      expect(replaceDashesWithUnderscores('')).toBe('')
+    })
+
+    it('should handle string with only dashes', () => {
+      expect(replaceDashesWithUnderscores('---')).toBe('___')
+    })
+
+    it('should handle consecutive dashes', () => {
+      expect(replaceDashesWithUnderscores('my--package')).toBe('my__package')
+    })
+
+    it('should handle dashes at start and end', () => {
+      expect(replaceDashesWithUnderscores('-package-')).toBe('_package_')
+    })
+  })
+
+  describe('replaceUnderscoresWithDashes', () => {
+    it('should replace all underscores with dashes', () => {
+      expect(replaceUnderscoresWithDashes('my_package_name')).toBe(
+        'my-package-name',
+      )
+    })
+
+    it('should handle string without underscores', () => {
+      expect(replaceUnderscoresWithDashes('mypackage')).toBe('mypackage')
+    })
+
+    it('should handle empty string', () => {
+      expect(replaceUnderscoresWithDashes('')).toBe('')
+    })
+
+    it('should handle string with only underscores', () => {
+      expect(replaceUnderscoresWithDashes('___')).toBe('---')
+    })
+
+    it('should handle consecutive underscores', () => {
+      expect(replaceUnderscoresWithDashes('my__package')).toBe('my--package')
+    })
+
+    it('should handle underscores at start and end', () => {
+      expect(replaceUnderscoresWithDashes('_package_')).toBe('-package-')
+    })
+  })
+
+  describe('trimLeadingSlashes', () => {
+    it('should remove leading slashes', () => {
+      expect(trimLeadingSlashes('/path/to/package')).toBe('path/to/package')
+      expect(trimLeadingSlashes('//path/to/package')).toBe('path/to/package')
+      expect(trimLeadingSlashes('///path')).toBe('path')
+    })
+
+    it('should handle string without leading slashes', () => {
+      expect(trimLeadingSlashes('path/to/package')).toBe('path/to/package')
+    })
+
+    it('should handle empty string', () => {
+      expect(trimLeadingSlashes('')).toBe('')
+    })
+
+    it('should handle string with only slashes', () => {
+      expect(trimLeadingSlashes('///')).toBe('')
+    })
+
+    it('should preserve trailing slashes', () => {
+      expect(trimLeadingSlashes('/path/')).toBe('path/')
+    })
+
+    it('should preserve internal slashes', () => {
+      expect(trimLeadingSlashes('/path/to/package')).toBe('path/to/package')
+    })
+  })
+})