test: add unit tests for lang and helpers utilities

Add explicit unit tests for isNullishOrEmptyString and createHelpersNamespaceObject functions that were previously only tested indirectly.

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

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

Author: jdalton

test/helpers.test.mts

@@ -0,0 +1,133 @@
+import { describe, expect, it } from 'vitest'
+
+import { createHelpersNamespaceObject } from '../src/helpers.js'
+
+describe('Helpers utilities', () => {
+  describe('createHelpersNamespaceObject', () => {
+    it('should create namespace object with basic helpers', () => {
+      const helpers = {
+        helper1: { prop1: 'value1', prop2: 'value2' },
+        helper2: { prop1: 'value3', prop3: 'value4' },
+      }
+      const result = createHelpersNamespaceObject(helpers)
+
+      expect(result['prop1']).toEqual({
+        helper1: 'value1',
+        helper2: 'value3',
+      })
+      expect(result['prop2']).toEqual({ helper1: 'value2' })
+      expect(result['prop3']).toEqual({ helper2: 'value4' })
+    })
+
+    it('should handle empty helpers object', () => {
+      const helpers = {}
+      const result = createHelpersNamespaceObject(helpers)
+      expect(result).toEqual({})
+    })
+
+    it('should use defaults when property not found', () => {
+      const helpers = {
+        helper1: { prop1: 'value1' },
+        helper2: { prop2: 'value2' },
+      }
+      const defaults = { helper1: 'default1', helper2: 'default2' }
+      const result = createHelpersNamespaceObject(helpers, defaults)
+
+      expect(result['prop1']).toEqual({
+        helper1: 'value1',
+        helper2: 'default2',
+      })
+      expect(result['prop2']).toEqual({
+        helper1: 'default1',
+        helper2: 'value2',
+      })
+    })
+
+    it('should skip undefined defaults', () => {
+      const helpers = {
+        helper1: { prop1: 'value1' },
+      }
+      const defaults = { helper1: undefined }
+      const result = createHelpersNamespaceObject(helpers, defaults)
+
+      expect(result['prop1']).toEqual({ helper1: 'value1' })
+    })
+
+    it('should sort property names alphabetically by default', () => {
+      const helpers = {
+        helper1: { zProp: 'z', aProp: 'a', mProp: 'm' },
+      }
+      const result = createHelpersNamespaceObject(helpers)
+
+      const keys = Object.keys(result)
+      expect(keys).toEqual(['aProp', 'mProp', 'zProp'])
+    })
+
+    it('should use custom comparator for sorting', () => {
+      const helpers = {
+        helper1: { prop1: 'value1', prop2: 'value2', prop3: 'value3' },
+      }
+      // Reverse alphabetical order
+      const comparator = (a: string, b: string) => b.localeCompare(a)
+      const result = createHelpersNamespaceObject(helpers, { comparator })
+
+      const keys = Object.keys(result)
+      expect(keys).toEqual(['prop3', 'prop2', 'prop1'])
+    })
+
+    it('should handle helpers with null prototype', () => {
+      const helper1 = Object.create(null)
+      helper1.prop1 = 'value1'
+
+      const helpers = { helper1 }
+      const result = createHelpersNamespaceObject(helpers)
+
+      expect(result['prop1']).toEqual({ helper1: 'value1' })
+    })
+
+    it('should collect unique property names from all helpers', () => {
+      const helpers = {
+        helper1: { prop1: 'v1', prop2: 'v2' },
+        helper2: { prop2: 'v3', prop3: 'v4' },
+        helper3: { prop1: 'v5', prop3: 'v6', prop4: 'v7' },
+      }
+      const result = createHelpersNamespaceObject(helpers)
+
+      expect(Object.keys(result).sort()).toEqual([
+        'prop1',
+        'prop2',
+        'prop3',
+        'prop4',
+      ])
+    })
+
+    it('should handle helpers with undefined values', () => {
+      const helpers = {
+        helper1: { prop1: 'value1', prop2: undefined },
+        helper2: { prop1: undefined, prop2: 'value2' },
+      }
+      const result = createHelpersNamespaceObject(helpers)
+
+      expect(result['prop1']).toEqual({ helper1: 'value1' })
+      expect(result['prop2']).toEqual({ helper2: 'value2' })
+    })
+
+    it('should handle multiple helpers with overlapping properties', () => {
+      const helpers = {
+        helper1: { shared: 'value1', unique1: 'u1' },
+        helper2: { shared: 'value2', unique2: 'u2' },
+        helper3: { shared: 'value3', unique3: 'u3' },
+      }
+      const result = createHelpersNamespaceObject(helpers)
+
+      expect(result['shared']).toEqual({
+        helper1: 'value1',
+        helper2: 'value2',
+        helper3: 'value3',
+      })
+      expect(result['unique1']).toEqual({ helper1: 'u1' })
+      expect(result['unique2']).toEqual({ helper2: 'u2' })
+      expect(result['unique3']).toEqual({ helper3: 'u3' })
+    })
+  })
+})

test/lang.test.mts

@@ -0,0 +1,48 @@
+import { describe, expect, it } from 'vitest'
+
+import { isNullishOrEmptyString } from '../src/lang.js'
+
+describe('Language utilities', () => {
+  describe('isNullishOrEmptyString', () => {
+    it('should return true for null', () => {
+      expect(isNullishOrEmptyString(null)).toBe(true)
+    })
+
+    it('should return true for undefined', () => {
+      expect(isNullishOrEmptyString(undefined)).toBe(true)
+    })
+
+    it('should return true for empty string', () => {
+      expect(isNullishOrEmptyString('')).toBe(true)
+    })
+
+    it('should return false for non-empty strings', () => {
+      expect(isNullishOrEmptyString('test')).toBe(false)
+      expect(isNullishOrEmptyString(' ')).toBe(false)
+      expect(isNullishOrEmptyString('0')).toBe(false)
+    })
+
+    it('should return false for numbers', () => {
+      expect(isNullishOrEmptyString(0)).toBe(false)
+      expect(isNullishOrEmptyString(123)).toBe(false)
+      expect(isNullishOrEmptyString(-1)).toBe(false)
+    })
+
+    it('should return false for booleans', () => {
+      expect(isNullishOrEmptyString(true)).toBe(false)
+      expect(isNullishOrEmptyString(false)).toBe(false)
+    })
+
+    it('should return false for objects', () => {
+      expect(isNullishOrEmptyString({})).toBe(false)
+      expect(isNullishOrEmptyString([])).toBe(false)
+      expect(isNullishOrEmptyString({ key: 'value' })).toBe(false)
+    })
+
+    it('should return false for functions', () => {
+      expect(isNullishOrEmptyString(() => {})).toBe(false)
+      // biome-ignore lint: testing function
+      expect(isNullishOrEmptyString(function () {})).toBe(false)
+    })
+  })
+})