@codeleap/styles 5.8.2 → 5.8.4

package/src/tools/tests/colors.spec.ts

@@ -0,0 +1,233 @@
+import { test, expect, describe } from 'bun:test'
+import { 
+  hexToHSL, 
+  hslToHex, 
+  hexToRGB, 
+  hslToRGB, 
+  getLuminance,
+  getTextColor 
+} from '../colors'
+
+describe('colors', () => {
+  describe('hexToHSL', () => {
+    test('should convert red hex to HSL', () => {
+      const result = hexToHSL('#ff0000')
+      expect(result).toEqual({ h: 0, s: 100, l: 50 })
+    })
+
+    test('should convert green hex to HSL', () => {
+      const result = hexToHSL('#00ff00')
+      expect(result).toEqual({ h: 120, s: 100, l: 50 })
+    })
+
+    test('should convert blue hex to HSL', () => {
+      const result = hexToHSL('#0000ff')
+      expect(result).toEqual({ h: 240, s: 100, l: 50 })
+    })
+
+    test('should convert white to HSL', () => {
+      const result = hexToHSL('#ffffff')
+      expect(result).toEqual({ h: 0, s: 0, l: 100 })
+    })
+
+    test('should convert black to HSL', () => {
+      const result = hexToHSL('#000000')
+      expect(result).toEqual({ h: 0, s: 0, l: 0 })
+    })
+
+    test('should handle custom colors', () => {
+      const result = hexToHSL('#ff5733')
+      expect(result.h).toBeGreaterThanOrEqual(0)
+      expect(result.h).toBeLessThanOrEqual(360)
+      expect(result.s).toBeGreaterThanOrEqual(0)
+      expect(result.s).toBeLessThanOrEqual(100)
+      expect(result.l).toBeGreaterThanOrEqual(0)
+      expect(result.l).toBeLessThanOrEqual(100)
+    })
+  })
+
+  describe('hslToHex', () => {
+    test('should convert HSL to red hex', () => {
+      const result = hslToHex(0, 100, 50)
+      expect(result).toBe('#ff0000')
+    })
+
+    test('should convert HSL to green hex', () => {
+      const result = hslToHex(120, 100, 50)
+      expect(result).toBe('#00ff00')
+    })
+
+    test('should convert HSL to blue hex', () => {
+      const result = hslToHex(240, 100, 50)
+      expect(result).toBe('#0000ff')
+    })
+
+    test('should convert HSL to white hex', () => {
+      const result = hslToHex(0, 0, 100)
+      expect(result).toBe('#ffffff')
+    })
+
+    test('should convert HSL to black hex', () => {
+      const result = hslToHex(0, 0, 0)
+      expect(result).toBe('#000000')
+    })
+  })
+
+  describe('hexToRGB', () => {
+    test('should convert red hex to RGB', () => {
+      const result = hexToRGB('#ff0000')
+      expect(result).toEqual({ r: 255, g: 0, b: 0 })
+    })
+
+    test('should convert green hex to RGB', () => {
+      const result = hexToRGB('#00ff00')
+      expect(result).toEqual({ r: 0, g: 255, b: 0 })
+    })
+
+    test('should convert blue hex to RGB', () => {
+      const result = hexToRGB('#0000ff')
+      expect(result).toEqual({ r: 0, g: 0, b: 255 })
+    })
+
+    test('should convert white hex to RGB', () => {
+      const result = hexToRGB('#ffffff')
+      expect(result).toEqual({ r: 255, g: 255, b: 255 })
+    })
+
+    test('should convert black hex to RGB', () => {
+      const result = hexToRGB('#000000')
+      expect(result).toEqual({ r: 0, g: 0, b: 0 })
+    })
+  })
+
+  describe('hslToRGB', () => {
+    test('should convert red HSL to RGB', () => {
+      const result = hslToRGB(0, 100, 50)
+      expect(result).toEqual({ r: 255, g: 0, b: 0 })
+    })
+
+    test('should convert green HSL to RGB', () => {
+      const result = hslToRGB(120, 100, 50)
+      expect(result).toEqual({ r: 0, g: 255, b: 0 })
+    })
+
+    test('should convert blue HSL to RGB', () => {
+      const result = hslToRGB(240, 100, 50)
+      expect(result).toEqual({ r: 0, g: 0, b: 255 })
+    })
+
+    test('should convert white HSL to RGB', () => {
+      const result = hslToRGB(0, 0, 100)
+      expect(result).toEqual({ r: 255, g: 255, b: 255 })
+    })
+
+    test('should convert black HSL to RGB', () => {
+      const result = hslToRGB(0, 0, 0)
+      expect(result).toEqual({ r: 0, g: 0, b: 0 })
+    })
+  })
+
+  describe('conversion roundtrip', () => {
+    test('hex -> HSL -> hex should maintain color integrity', () => {
+      const originalHex = '#ff5733'
+      const hsl = hexToHSL(originalHex)
+      const backToHex = hslToHex(hsl.h, hsl.s, hsl.l)
+      
+      // Allow for small rounding differences in conversion
+      const original = hexToRGB(originalHex)
+      const converted = hexToRGB(backToHex)
+      
+      expect(Math.abs(original.r - converted.r)).toBeLessThanOrEqual(1)
+      expect(Math.abs(original.g - converted.g)).toBeLessThanOrEqual(1)
+      expect(Math.abs(original.b - converted.b)).toBeLessThanOrEqual(1)
+    })
+
+    test('should work with primary colors (exact conversion)', () => {
+      const colors = ['#ff0000', '#00ff00', '#0000ff', '#ffffff', '#000000']
+      
+      colors.forEach(hex => {
+        const hsl = hexToHSL(hex)
+        const backToHex = hslToHex(hsl.h, hsl.s, hsl.l)
+        expect(backToHex).toBe(hex)
+      })
+    })
+  })
+
+  describe('getLuminance', () => {
+    test('should return 1 for white', () => {
+      const luminance = getLuminance({ r: 255, g: 255, b: 255 })
+      expect(luminance).toBeCloseTo(1, 2)
+    })
+
+    test('should return 0 for black', () => {
+      const luminance = getLuminance({ r: 0, g: 0, b: 0 })
+      expect(luminance).toBeCloseTo(0, 2)
+    })
+
+    test('should return values between 0 and 1', () => {
+      const colors = [
+        { r: 255, g: 0, b: 0 },    // Red
+        { r: 0, g: 255, b: 0 },    // Green
+        { r: 0, g: 0, b: 255 },    // Blue
+        { r: 128, g: 128, b: 128 } // Gray
+      ]
+
+      colors.forEach(color => {
+        const luminance = getLuminance(color)
+        expect(luminance).toBeGreaterThanOrEqual(0)
+        expect(luminance).toBeLessThanOrEqual(1)
+      })
+    })
+
+    test('should calculate different values for different colors', () => {
+      const red = getLuminance({ r: 255, g: 0, b: 0 })
+      const green = getLuminance({ r: 0, g: 255, b: 0 })
+      const blue = getLuminance({ r: 0, g: 0, b: 255 })
+
+      expect(red).not.toBe(green)
+      expect(green).not.toBe(blue)
+      expect(red).not.toBe(blue)
+    })
+  })
+
+  describe('getTextColor', () => {
+    test('should return dark text for light backgrounds', () => {
+      const textColor = getTextColor('#ffffff') // White background
+      expect(textColor).toBe('black')
+    })
+
+    test('should return light text for dark backgrounds', () => {
+      const textColor = getTextColor('#000000') // Black background
+      expect(textColor).toBe('white')
+    })
+
+    test('should use custom colors when provided', () => {
+      const textColor = getTextColor('#ffffff', '#333333', '#f0f0f0')
+      expect(textColor).toBe('#333333')
+    })
+
+    test('should handle medium brightness colors', () => {
+      const lightGray = getTextColor('#cccccc')
+      const darkGray = getTextColor('#333333')
+      
+      expect(lightGray).toBe('black')
+      expect(darkGray).toBe('white')
+    })
+
+    test('should be consistent with luminance calculations', () => {
+      const colors = ['#ff0000', '#00ff00', '#0000ff', '#ffff00', '#ff00ff', '#00ffff']
+      
+      colors.forEach(hex => {
+        const rgb = hexToRGB(hex)
+        const luminance = getLuminance(rgb)
+        const textColor = getTextColor(hex)
+        
+        if (luminance > 0.5) {
+          expect(textColor).toBe('black')
+        } else {
+          expect(textColor).toBe('white')
+        }
+      })
+    })
+  })
+})

package/src/tools/tests/deepClone.spec.ts

@@ -0,0 +1,102 @@
+import { test, expect, describe } from 'bun:test'
+import { deepClone } from '../deepClone'
+
+describe('deepClone', () => {
+  test('should clone primitive values', () => {
+    expect(deepClone(42)).toBe(42)
+    expect(deepClone('hello')).toBe('hello')
+    expect(deepClone(true)).toBe(true)
+    expect(deepClone(null)).toBe(null)
+    expect(deepClone(undefined)).toBe(undefined)
+  })
+
+  test('should create independent copy of objects', () => {
+    const original = { name: 'John', age: 30 }
+    const cloned = deepClone(original)
+    
+    expect(cloned).toEqual(original)
+    expect(cloned).not.toBe(original)
+    
+    cloned.name = 'Jane'
+    expect(original.name).toBe('John')
+  })
+
+  test('should clone nested objects', () => {
+    const original = {
+      user: { name: 'John', details: { age: 30, city: 'NY' } },
+      settings: { theme: 'dark' }
+    }
+    const cloned = deepClone(original)
+    
+    expect(cloned).toEqual(original)
+    expect(cloned.user).not.toBe(original.user)
+    expect(cloned.user.details).not.toBe(original.user.details)
+    
+    cloned.user.details.age = 31
+    expect(original.user.details.age).toBe(30)
+  })
+
+  test('should clone arrays', () => {
+    const original = [1, 2, [3, 4]]
+    const cloned = deepClone(original)
+    
+    expect(cloned).toEqual(original)
+    expect(cloned).not.toBe(original)
+    expect(cloned[2]).not.toBe(original[2])
+    
+    cloned[2][0] = 5
+    expect(original[2][0]).toBe(3)
+  })
+
+  test('should handle complex nested structures', () => {
+    const original = {
+      items: [
+        { id: 1, tags: ['red', 'blue'] },
+        { id: 2, tags: ['green'] }
+      ],
+      meta: { count: 2, filters: { active: true } }
+    }
+    const cloned = deepClone(original)
+    
+    expect(cloned).toEqual(original)
+    
+    cloned.items[0].tags.push('yellow')
+    cloned.meta.filters.active = false
+    
+    expect(original.items[0].tags).toHaveLength(2)
+    expect(original.meta.filters.active).toBe(true)
+  })
+
+  test('should handle dates', () => {
+    const original = new Date('2023-01-01')
+    const cloned = deepClone(original)
+    
+    expect(cloned).toEqual(original)
+    expect(cloned).not.toBe(original)
+    expect(cloned instanceof Date).toBe(true)
+  })
+
+  test('should handle empty objects and arrays', () => {
+    const emptyObj = deepClone({})
+    const emptyArr = deepClone([])
+    
+    expect(emptyObj).toEqual({})
+    expect(emptyArr).toEqual([])
+  })
+
+  test('should clone class instances as plain objects', () => {
+    class Person {
+      constructor(public name: string) {}
+      greet() { return `Hello, ${this.name}` }
+    }
+    
+    const original = new Person('John')
+    const cloned = deepClone(original) as any
+    
+    expect(cloned).toEqual({ name: 'John' })
+    expect(cloned).not.toBe(original)
+    expect((cloned as any).name).toBe('John')
+    // Methods are not cloned, only data properties
+    expect((cloned as any).greet).toBeUndefined()
+  })
+})

package/src/tools/tests/deepmerge.spec.ts

@@ -0,0 +1,155 @@
+import { test, expect, describe } from 'bun:test'
+import { deepmerge } from '../deepmerge'
+
+describe('deepmerge', () => {
+  const merge = deepmerge()
+
+  test('should merge simple objects', () => {
+    const target = { a: 1, b: 2 }
+    const source = { b: 3, c: 4 }
+    const result = merge(target, source)
+    
+    expect(result).toEqual({ a: 1, b: 3, c: 4 })
+    expect(result).not.toBe(target)
+    expect(result).not.toBe(source)
+  })
+
+  test('should merge nested objects', () => {
+    const target = { 
+      user: { name: 'John', age: 30 },
+      settings: { theme: 'light' }
+    }
+    const source = { 
+      user: { age: 31, city: 'NY' },
+      settings: { language: 'en' }
+    }
+    const result = merge(target, source)
+    
+    expect(result).toEqual({
+      user: { name: 'John', age: 31, city: 'NY' },
+      settings: { theme: 'light', language: 'en' }
+    })
+  })
+
+  test('should concatenate arrays by default', () => {
+    const target = { items: [1, 2, 3] }
+    const source = { items: [4, 5] }
+    const result = merge(target, source)
+    
+    expect(result).toEqual({ items: [1, 2, 3, 4, 5] })
+  })
+
+  test('should handle mixed data types', () => {
+    const target = {
+      string: 'hello',
+      number: 42,
+      boolean: true,
+      nested: { a: 1 }
+    }
+    const source = {
+      string: 'world',
+      array: [1, 2, 3],
+      nested: { b: 2 }
+    }
+    const result = merge(target, source)
+    
+    expect(result).toEqual({
+      string: 'world',
+      number: 42,
+      boolean: true,
+      array: [1, 2, 3],
+      nested: { a: 1, b: 2 }
+    })
+  })
+
+  test('should not mutate original objects', () => {
+    const target = { a: { x: 1 }, arr: [1] }
+    const source = { a: { y: 2 }, arr: [2] }
+    
+    const result = merge(target, source)
+    
+    expect(target.a).toEqual({ x: 1 })
+    expect(target.arr).toEqual([1])
+    expect(source.a).toEqual({ y: 2 })
+    expect(source.arr).toEqual([2])
+    expect(result.a).toEqual({ x: 1, y: 2 })
+    expect(result.arr).toEqual([1, 2])
+  })
+
+  test('should handle primitive values', () => {
+    const result1 = merge({ a: 1 }, { a: 'string' })
+    const result2 = merge({ a: null }, { a: 'value' })
+    const result3 = merge({ a: undefined }, { a: 42 })
+    
+    expect(result1).toEqual({ a: 'string' })
+    expect(result2).toEqual({ a: 'value' })
+    expect(result3).toEqual({ a: 42 })
+  })
+
+  test('should handle RegExp and Date objects', () => {
+    const target = { regex: /old/, date: new Date('2023-01-01') }
+    const source = { regex: /new/, date: new Date('2024-01-01') }
+    const result = merge(target, source)
+    
+    expect(result.regex).toEqual(/new/)
+    expect(result.date).toEqual(new Date('2024-01-01'))
+    expect(result.regex).not.toBe(target.regex)
+    expect(result.date).not.toBe(target.date)
+  })
+
+  test('should merge multiple levels deep', () => {
+    const target = {
+      level1: {
+        level2: {
+          level3: { a: 1, b: 2 }
+        }
+      }
+    }
+    const source = {
+      level1: {
+        level2: {
+          level3: { b: 3, c: 4 },
+          other: 'value'
+        }
+      }
+    }
+    const result = merge(target, source)
+    
+    expect(result).toEqual({
+      level1: {
+        level2: {
+          level3: { a: 1, b: 3, c: 4 },
+          other: 'value'
+        }
+      }
+    })
+  })
+
+  test('should handle empty objects', () => {
+    const result1 = merge({}, { a: 1 })
+    const result2 = merge({ a: 1 }, {})
+    
+    expect(result1).toEqual({ a: 1 })
+    expect(result2).toEqual({ a: 1 })
+  })
+
+  test('should handle array vs object type mismatch', () => {
+    const result1 = merge({ a: [1, 2] }, { a: { x: 1 } })
+    const result2 = merge({ a: { x: 1 } }, { a: [1, 2] })
+    
+    expect(result1).toEqual({ a: { x: 1 } })
+    expect(result2).toEqual({ a: [1, 2] })
+  })
+
+  test('should support mergeAll option', () => {
+    const mergeAll = deepmerge({ all: true })
+    const result = mergeAll(
+      { a: 1 },
+      { b: 2 },
+      { c: 3 },
+      { a: 10 }
+    )
+    
+    expect(result).toEqual({ a: 10, b: 2, c: 3 })
+  })
+})

package/src/tools/tests/hashKey.spec.ts

@@ -0,0 +1,69 @@
+import { test, expect, describe } from 'bun:test'
+import { hashKey } from '../hashKey'
+
+describe('hashKey', () => {
+  test('should generate consistent hash for same input', () => {
+    const input = ['style1', 'style2']
+    const hash1 = hashKey([...input])
+    const hash2 = hashKey([...input])
+    
+    expect(hash1).toBe(hash2)
+  })
+
+  test('should generate different hashes for different inputs', () => {
+    const input1 = ['style1', 'style2']
+    const input2 = ['style3', 'style4']
+    
+    const hash1 = hashKey([...input1])
+    const hash2 = hashKey([...input2])
+    
+    expect(hash1).not.toBe(hash2)
+  })
+
+  test('should return a valid SHA-256 hash string', () => {
+    const input = ['test']
+    const hash = hashKey([...input])
+    
+    // SHA-256 hash should be 64 characters long (hex)
+    expect(hash).toHaveLength(64)
+    expect(hash).toMatch(/^[a-f0-9]{64}$/)
+  })
+
+  test('should handle empty array', () => {
+    const hash = hashKey([])
+    
+    expect(hash).toHaveLength(64)
+    expect(hash).toMatch(/^[a-f0-9]{64}$/)
+  })
+
+  test('should handle arrays with objects', () => {
+    const input = [{ color: 'red' }, { fontSize: '14px' }]
+    const hash = hashKey([...input])
+    
+    expect(hash).toHaveLength(64)
+    expect(hash).toMatch(/^[a-f0-9]{64}$/)
+  })
+
+  test('should mutate original array by adding version', () => {
+    const input = ['style1']
+    const originalLength = input.length
+    
+    hashKey(input)
+    
+    expect(input).toHaveLength(originalLength + 1)
+    expect(input[input.length - 1]).toHaveProperty('@styles-version')
+  })
+
+  test('should include version in hash calculation', () => {
+    // Mock different versions to test version impact
+    const input = ['same-style']
+    
+    const hash1 = hashKey([...input])
+    
+    // Simulate version change by adding version manually
+    const inputWithDifferentVersion = [...input, { '@styles-version': 'different-version' }]
+    const hash2 = hashKey([...inputWithDifferentVersion])
+    
+    expect(hash1).not.toBe(hash2)
+  })
+})