@splendidlabz/utils 1.7.0 → 1.8.2

package/src/lib/functions/functional.test.js

@@ -0,0 +1,196 @@
+import { describe, expect, it } from 'vitest'
+import {
+  compose,
+  composeAsync,
+  curry,
+  pipe,
+  pipeAsync,
+  times,
+} from './functional.js'
+
+describe('functional utilities', () => {
+  describe('curry', () => {
+    it('should curry a function with multiple arguments', () => {
+      const add = (a, b, c) => a + b + c
+      const curriedAdd = curry(add)
+
+      expect(curriedAdd(1)(2)(3)).toBe(6)
+      expect(curriedAdd(1, 2)(3)).toBe(6)
+      expect(curriedAdd(1)(2, 3)).toBe(6)
+      expect(curriedAdd(1, 2, 3)).toBe(6)
+    })
+  })
+
+  describe('compose (sync)', () => {
+    it('should compose functions from right to left', () => {
+      const add1 = x => x + 1
+      const multiply2 = x => x * 2
+      const composed = compose(add1, multiply2)
+
+      expect(composed(3)).toBe(7) // (3 * 2) + 1
+    })
+
+    it('should work with single function', () => {
+      const add1 = x => x + 1
+      const composed = compose(add1)
+
+      expect(composed(5)).toBe(6)
+    })
+
+    it('should work with multiple functions', () => {
+      const add1 = x => x + 1
+      const multiply2 = x => x * 2
+      const subtract3 = x => x - 3
+      const composed = compose(subtract3, add1, multiply2)
+
+      expect(composed(5)).toBe(8) // ((5 * 2) + 1) - 3 = 8
+    })
+  })
+
+  describe('composeAsync', () => {
+    it('should compose async functions from right to left', async () => {
+      const add1 = x => x + 1
+      const multiplyAsync = async x => x * 2
+
+      const result = await composeAsync(add1, multiplyAsync)(3)
+      expect(result).toBe(7) // (3 * 2) + 1
+    })
+
+    it('should work with all sync functions', async () => {
+      const add1 = x => x + 1
+      const multiply2 = x => x * 2
+
+      const result = await composeAsync(add1, multiply2)(3)
+      expect(result).toBe(7) // (3 * 2) + 1
+    })
+
+    it('should work with all async functions', async () => {
+      const add1Async = async x => x + 1
+      const multiply2Async = async x => x * 2
+
+      const result = await composeAsync(add1Async, multiply2Async)(3)
+      expect(result).toBe(7) // (3 * 2) + 1
+    })
+
+    it('should work with mixed sync and async functions', async () => {
+      const add1 = x => x + 1
+      const multiply2Async = async x => x * 2
+      const subtract3 = x => x - 3
+
+      const result = await composeAsync(subtract3, add1, multiply2Async)(5)
+      expect(result).toBe(8) // ((5 * 2) + 1) - 3 = 8
+    })
+  })
+
+  describe('pipe (sync)', () => {
+    it('should pipe functions from left to right', () => {
+      const add1 = x => x + 1
+      const multiply2 = x => x * 2
+      const piped = pipe(add1, multiply2)
+
+      expect(piped(3)).toBe(8) // (3 + 1) * 2
+    })
+
+    it('should work with single function', () => {
+      const add1 = x => x + 1
+      const piped = pipe(add1)
+
+      expect(piped(5)).toBe(6)
+    })
+
+    it('should work with multiple functions', () => {
+      const add1 = x => x + 1
+      const multiply2 = x => x * 2
+      const subtract3 = x => x - 3
+      const piped = pipe(add1, multiply2, subtract3)
+
+      expect(piped(5)).toBe(9) // ((5 + 1) * 2) - 3 = 9
+    })
+  })
+
+  describe('pipeAsync', () => {
+    it('should pipe async functions from left to right', async () => {
+      const add1 = x => x + 1
+      const multiplyAsync = async x => x * 2
+
+      const result = await pipeAsync(add1, multiplyAsync)(3)
+      expect(result).toBe(8) // (3 + 1) * 2
+    })
+
+    it('should work with all sync functions', async () => {
+      const add1 = x => x + 1
+      const multiply2 = x => x * 2
+
+      const result = await pipeAsync(add1, multiply2)(3)
+      expect(result).toBe(8) // (3 + 1) * 2
+    })
+
+    it('should work with all async functions', async () => {
+      const add1Async = async x => x + 1
+      const multiply2Async = async x => x * 2
+
+      const result = await pipeAsync(add1Async, multiply2Async)(3)
+      expect(result).toBe(8) // (3 + 1) * 2
+    })
+
+    it('should work with mixed sync and async functions', async () => {
+      const add1 = x => x + 1
+      const multiply2Async = async x => x * 2
+      const subtract3 = x => x - 3
+
+      const result = await pipeAsync(add1, multiply2Async, subtract3)(5)
+      expect(result).toBe(9) // ((5 + 1) * 2) - 3 = 9
+    })
+
+    it('should handle promises in the pipeline', async () => {
+      const asyncAdd = async x => {
+        await new Promise(resolve => setTimeout(resolve, 1))
+        return x + 1
+      }
+      const multiply2 = x => x * 2
+
+      const result = await pipeAsync(asyncAdd, multiply2)(3)
+      expect(result).toBe(8) // (3 + 1) * 2
+    })
+  })
+
+  describe('times', () => {
+    it('should call function n times with index', () => {
+      const result = times(i => i * 2, 3)
+      expect(result).toEqual([0, 2, 4])
+    })
+
+    it('should work with zero iterations', () => {
+      const result = times(i => i, 0)
+      expect(result).toEqual([])
+    })
+
+    it('should work with functions that ignore index', () => {
+      const result = times(() => 'hello', 2)
+      expect(result).toEqual(['hello', 'hello'])
+    })
+  })
+
+  // Edge cases and error handling
+  describe('edge cases', () => {
+    it('should handle empty function arrays in compose', () => {
+      const composed = compose()
+      expect(composed(5)).toBe(5)
+    })
+
+    it('should handle empty function arrays in pipe', () => {
+      const piped = pipe()
+      expect(piped(5)).toBe(5)
+    })
+
+    it('should handle empty function arrays in composeAsync', async () => {
+      const result = await composeAsync()(5)
+      expect(result).toBe(5)
+    })
+
+    it('should handle empty function arrays in pipeAsync', async () => {
+      const result = await pipeAsync()(5)
+      expect(result).toBe(5)
+    })
+  })
+})

package/src/lib/numbers/index.js

@@ -4,7 +4,7 @@ export function splitUnit(string) {
   // If there are no units, return the number straight.
   if (typeof string === 'number') return [string, null]
 
-  const regex = /(-?\d*\.?\d+)([a-z]+)/i
+  const regex = /(-?\d*\.?\d+)\s*([a-z]+)/i
   const match = string.match(regex)
 
   if (match) return [parseFloat(match[1]), match[2]]

package/src/lib/numbers/split-unit.test.js

@@ -0,0 +1,45 @@
+import { describe, expect, test } from 'vitest'
+import { splitUnit } from './index.js'
+
+describe('splitUnit', () => {
+  test('handles number input', () => {
+    const result = splitUnit(42)
+    expect(result).toEqual([42, null])
+  })
+
+  test('handles unitless string numbers', () => {
+    const result = splitUnit('100')
+    expect(result).toEqual([100, null])
+  })
+
+  test('handles "3hours" without space', () => {
+    const result = splitUnit('3hours')
+    expect(result).toEqual([3, 'hours'])
+  })
+
+  test('handles "2rem" CSS unit', () => {
+    const result = splitUnit('2rem')
+    expect(result).toEqual([2, 'rem'])
+  })
+
+  test('handles decimal values', () => {
+    const result = splitUnit('1.5em')
+    expect(result).toEqual([1.5, 'em'])
+  })
+
+  test('handles negative values', () => {
+    const result = splitUnit('-10px')
+    expect(result).toEqual([-10, 'px'])
+  })
+
+  // Tests with spaces
+  test('handles values with spaces', () => {
+    const result = splitUnit('30 days')
+    expect(result).toEqual([30, 'days'])
+  })
+
+  test('handles values with many spaces between number and unit', () => {
+    const result = splitUnit('10   em')
+    expect(result).toEqual([10, 'em'])
+  })
+})

package/src/lib/objects/mix/mix.js

@@ -1,7 +1,45 @@
-const DEFAULT_OPTIONS = { array: 'concat' }
-
+const DEFAULT_OPTIONS = { array: 'replace' } // Can be concat or replace
+
+/**
+ * Deep merges multiple objects into a new object with intelligent handling of arrays and nested objects.
+ *
+ * @param {...Object} sources - Objects to merge. Null and undefined values are skipped.
+ * @return {Object} A new object containing the merged properties from all sources.
+ *
+ * @example
+ * const obj1 = { a: 1, b: { x: 10 } }
+ * const obj2 = { b: { y: 20 }, c: 3 }
+ * const result = mix(obj1, obj2)
+ * // Returns: { a: 1, b: { x: 10, y: 20 }, c: 3 }
+ */
 export const mix = createMix()
-
+export const concatMix = createMix({ array: 'concat' })
+
+/**
+ * Creates a customized mix function with specific options for array handling.
+ *
+ * @param {Object} [userOptions={}] - Configuration options for the mix function.
+ * @param {('replace'|'concat')} [userOptions.array='replace'] - How to handle array merging:
+ *   - 'replace': Arrays from later sources completely replace arrays from earlier sources
+ *   - 'concat': Arrays are concatenated together
+ * @return {Function} A mix function configured with the provided options.
+ *
+ * @example
+ * // Create mix function that concatenates arrays
+ * const concatMix = createMix({ array: 'concat' })
+ * const obj1 = { items: [1, 2] }
+ * const obj2 = { items: [3, 4] }
+ * const result = concatMix(obj1, obj2)
+ * // Returns: { items: [1, 2, 3, 4] }
+ *
+ * @example
+ * // Create mix function that replaces arrays (default behavior)
+ * const replaceMix = createMix({ array: 'replace' })
+ * const obj1 = { items: [1, 2] }
+ * const obj2 = { items: [3, 4] }
+ * const result = replaceMix(obj1, obj2)
+ * // Returns: { items: [3, 4] }
+ */
 export function createMix(userOptions = {}) {
   const options = { ...DEFAULT_OPTIONS, ...userOptions }
 
@@ -18,6 +56,15 @@ export function createMix(userOptions = {}) {
   return _mix
 }
 
+/**
+ * Recursively merges properties from input object into output object.
+ * Handles property descriptors, prevents prototype pollution, and deep clones values.
+ *
+ * @param {Object} output - The target object to merge properties into.
+ * @param {Object} input - The source object to merge properties from.
+ * @param {Object} options - Merge options including array handling strategy.
+ * @property {('replace'|'concat')} options.array - How to handle array merging.
+ */
 function merge(output, input, options) {
   const props = Object.keys(input)
 
@@ -63,7 +110,18 @@ function merge(output, input, options) {
   }
 }
 
-// Creates a deep clone for each value
+/**
+ * Creates a deep clone of a property descriptor value.
+ * Handles arrays, objects, dates, maps, sets, and other types appropriately.
+ *
+ * @param {*} value - The value to clone.
+ * @return {*} A deep clone of the input value.
+ * @property {Array} value - Cloned recursively with all elements deep cloned.
+ * @property {Object} value - Cloned with all properties and descriptors preserved.
+ * @property {Date} value - Cloned as new Date with same time value.
+ * @property {Map} value - Cloned with all entries deep cloned.
+ * @property {Set} value - Cloned with all entries deep cloned.
+ */
 function cloneDescriptorValue(value) {
   // Arrays
   if (objectType(value) === '[object Array]') {
@@ -116,6 +174,18 @@ function cloneDescriptorValue(value) {
   return value
 }
 
+/**
+ * Returns the precise object type of a value using Object.prototype.toString.
+ *
+ * @param {*} value - The value to get the type of.
+ * @return {string} The object type string (e.g., '[object Array]', '[object Object]', '[object Date]').
+ *
+ * @example
+ * objectType([]) // '[object Array]'
+ * objectType({}) // '[object Object]'
+ * objectType(new Date()) // '[object Date]'
+ * objectType(null) // '[object Null]'
+ */
 function objectType(value) {
   return Object.prototype.toString.call(value)
 }

package/src/lib/objects/mix/mix.test.js

@@ -1,6 +1,6 @@
 import { expect, it } from 'vitest'
 
-import { createMix, mix } from './mix.js'
+import { concatMix, createMix, mix } from './mix.js'
 
 it('Merge objects', () => {
   const one = { one: 'one', overwrite: 'nope' }
@@ -176,7 +176,8 @@ it('Double objects with nested same array', () => {
 
   const three = mix(one, two)
   expect(typeof three.array.push).toBe('function')
-  expect(three.array).toHaveLength(6)
+  expect(three.array).toHaveLength(3)
+  expect(three.array).toEqual([4, 5, 6])
 })
 
 it('Objects in Arrays', () => {
@@ -217,6 +218,54 @@ it('Deep nested arrays', () => {
   expect(two.array[1]).not.toBe(three.array[1])
 })
 
+it('concatMix: concatenates arrays', () => {
+  const one = {
+    array: [1, 2, 3],
+  }
+  const two = {
+    array: [4, 5, 6],
+  }
+
+  const three = concatMix(one, two)
+  expect(typeof three.array.push).toBe('function')
+  expect(three.array).toHaveLength(6)
+  expect(three.array).toEqual([1, 2, 3, 4, 5, 6])
+})
+
+it('concatMix: empty array concat', () => {
+  const one = {}
+  const two = { array: [1, 2, 3] }
+  const three = concatMix(one, two)
+
+  expect(three).toEqual(two)
+  expect(typeof three.array.push).toBe('function')
+  expect(three.array).toHaveLength(3)
+
+  // Prevent mutation
+  three.array.push(4)
+  expect(two.array).toHaveLength(3)
+  expect(three.array).toHaveLength(4)
+})
+
+it('concatMix: nested objects with concatenated arrays', () => {
+  const one = {
+    nested: {
+      items: [1, 2],
+      other: 'value1',
+    },
+  }
+  const two = {
+    nested: {
+      items: [3, 4],
+      other: 'value2',
+    },
+  }
+
+  const three = concatMix(one, two)
+  expect(three.nested.items).toEqual([1, 2, 3, 4])
+  expect(three.nested.other).toBe('value2')
+})
+
 it('Functions (cannot be cloned)', () => {
   const one = {}
   const two = {

package/src/node/file-cache.js

@@ -1,5 +1,5 @@
 import fs from 'fs/promises'
-import glob from 'glob-promise'
+import { glob } from 'glob'
 import path from 'node:path'
 import { sort } from '../lib/arrays/index.js'