@splendidlabz/utils 1.11.3 → 1.11.5

package/src/lib/hash.js

@@ -1,18 +0,0 @@
-export function isHashedValue(value, type = 'sha256') {
-  if (typeof value !== 'string') return null
-  value = value.trim()
-  type = type.toLowerCase()
-
-  if (type === 'sha256') {
-    return value.length === 64 && /^[a-fA-F0-9]{64}$/.test(value)
-  }
-
-  if (type === 'sha1') {
-    return value.length === 40 && /^[a-fA-F0-9]{40}$/.test(value)
-  }
-
-  if (type === 'md5') {
-    return value.length === 32 && /^[a-fA-F0-9]{32}$/.test(value)
-  }
-  return null
-}

package/src/lib/hash.spec.js

@@ -1,163 +0,0 @@
-import { describe, expect, it } from 'vitest'
-import { isHashedValue } from './hash.js'
-
-describe('isHashedValue', () => {
-  describe('SHA256 hashes', () => {
-    it('returns true for valid SHA256 hash', () => {
-      const validSha256 =
-        'a665a45920422f9d417e4867efdc4fb8a04a1f3fff1fa07e998e86f7f7a27ae3'
-      expect(isHashedValue(validSha256, 'sha256')).toBe(true)
-      expect(isHashedValue(validSha256)).toBe(true) // default type
-    })
-
-    it('returns true for valid SHA256 hash with uppercase letters', () => {
-      const validSha256 =
-        'A665A45920422F9D417E4867EFDC4FB8A04A1F3FFF1FA07E998E86F7F7A27AE3'
-      expect(isHashedValue(validSha256, 'sha256')).toBe(true)
-    })
-
-    it('returns true for valid SHA256 hash with mixed case', () => {
-      const validSha256 =
-        'A665a45920422F9d417E4867efdc4FB8a04a1F3fff1FA07e998E86f7f7A27ae3'
-      expect(isHashedValue(validSha256, 'sha256')).toBe(true)
-    })
-
-    it('returns false for SHA256 hash with wrong length', () => {
-      const shortHash =
-        'a665a45920422f9d417e4867efdc4fb8a04a1f3fff1fa07e998e86f7f7a27ae'
-      const longHash =
-        'a665a45920422f9d417e4867efdc4fb8a04a1f3fff1fa07e998e86f7f7a27ae33'
-      expect(isHashedValue(shortHash, 'sha256')).toBe(false)
-      expect(isHashedValue(longHash, 'sha256')).toBe(false)
-    })
-
-    it('returns false for SHA256 hash with invalid characters', () => {
-      const invalidHash =
-        'g665a45920422f9d417e4867efdc4fb8a04a1f3fff1fa07e998e86f7f7a27ae3'
-      expect(isHashedValue(invalidHash, 'sha256')).toBe(false)
-    })
-  })
-
-  describe('SHA1 hashes', () => {
-    it('returns true for valid SHA1 hash', () => {
-      const validSha1 = '356a192b7913b04c54574d18c28d46e6395428ab'
-      expect(isHashedValue(validSha1, 'sha1')).toBe(true)
-    })
-
-    it('returns true for valid SHA1 hash with uppercase letters', () => {
-      const validSha1 = '356A192B7913B04C54574D18C28D46E6395428AB'
-      expect(isHashedValue(validSha1, 'sha1')).toBe(true)
-    })
-
-    it('returns false for SHA1 hash with wrong length', () => {
-      const shortHash = '356a192b7913b04c54574d18c28d46e6395428a'
-      const longHash = '356a192b7913b04c54574d18c28d46e6395428abb'
-      expect(isHashedValue(shortHash, 'sha1')).toBe(false)
-      expect(isHashedValue(longHash, 'sha1')).toBe(false)
-    })
-
-    it('returns false for SHA1 hash with invalid characters', () => {
-      const invalidHash = '356g192b7913b04c54574d18c28d46e6395428ab'
-      expect(isHashedValue(invalidHash, 'sha1')).toBe(false)
-    })
-  })
-
-  describe('MD5 hashes', () => {
-    it('returns true for valid MD5 hash', () => {
-      const validMd5 = '5d41402abc4b2a76b9719d911017c592'
-      expect(isHashedValue(validMd5, 'md5')).toBe(true)
-    })
-
-    it('returns true for valid MD5 hash with uppercase letters', () => {
-      const validMd5 = '5D41402ABC4B2A76B9719D911017C592'
-      expect(isHashedValue(validMd5, 'md5')).toBe(true)
-    })
-
-    it('returns false for MD5 hash with wrong length', () => {
-      const shortHash = '5d41402abc4b2a76b9719d911017c59'
-      const longHash = '5d41402abc4b2a76b9719d911017c5922'
-      expect(isHashedValue(shortHash, 'md5')).toBe(false)
-      expect(isHashedValue(longHash, 'md5')).toBe(false)
-    })
-
-    it('returns false for MD5 hash with invalid characters', () => {
-      const invalidHash = '5g41402abc4b2a76b9719d911017c592'
-      expect(isHashedValue(invalidHash, 'md5')).toBe(false)
-    })
-  })
-
-  describe('Type parameter handling', () => {
-    it('handles case insensitive type parameter', () => {
-      const validSha256 =
-        'a665a45920422f9d417e4867efdc4fb8a04a1f3fff1fa07e998e86f7f7a27ae3'
-      expect(isHashedValue(validSha256, 'SHA256')).toBe(true)
-      expect(isHashedValue(validSha256, 'Sha256')).toBe(true)
-      expect(isHashedValue(validSha256, 'sHa256')).toBe(true)
-    })
-
-    it('returns null for unsupported hash type', () => {
-      const validSha256 =
-        'a665a45920422f9d417e4867efdc4fb8a04a1f3fff1fa07e998e86f7f7a27ae3'
-      expect(isHashedValue(validSha256, 'sha512')).toBe(null)
-      expect(isHashedValue(validSha256, 'blake2b')).toBe(null)
-      expect(isHashedValue(validSha256, 'unknown')).toBe(null)
-    })
-  })
-
-  describe('Input validation', () => {
-    it('returns null for non-string inputs', () => {
-      expect(isHashedValue(null)).toBe(null)
-      expect(isHashedValue(undefined)).toBe(null)
-      expect(isHashedValue(123)).toBe(null)
-      expect(isHashedValue([])).toBe(null)
-      expect(isHashedValue({})).toBe(null)
-      expect(isHashedValue(true)).toBe(null)
-    })
-
-    it('handles empty string', () => {
-      expect(isHashedValue('')).toBe(false)
-      expect(isHashedValue('', 'sha1')).toBe(false)
-      expect(isHashedValue('', 'md5')).toBe(false)
-    })
-
-    it('trims whitespace from input', () => {
-      const validSha256 =
-        '  a665a45920422f9d417e4867efdc4fb8a04a1f3fff1fa07e998e86f7f7a27ae3  '
-      expect(isHashedValue(validSha256, 'sha256')).toBe(true)
-    })
-
-    it('returns false for strings with only whitespace', () => {
-      expect(isHashedValue('   ')).toBe(false)
-      expect(isHashedValue('\t\n')).toBe(false)
-    })
-  })
-
-  describe('Edge cases', () => {
-    it('returns false for strings that are all zeros but correct length', () => {
-      const zeroSha256 =
-        '0000000000000000000000000000000000000000000000000000000000000000'
-      const zeroSha1 = '0000000000000000000000000000000000000000'
-      const zeroMd5 = '00000000000000000000000000000000'
-
-      expect(isHashedValue(zeroSha256, 'sha256')).toBe(true)
-      expect(isHashedValue(zeroSha1, 'sha1')).toBe(true)
-      expect(isHashedValue(zeroMd5, 'md5')).toBe(true)
-    })
-
-    it('returns false for correct length but non-hex characters', () => {
-      const nonHexSha256 =
-        'g665a45920422f9d417e4867efdc4fb8a04a1f3fff1fa07e998e86f7f7a27ae3'
-      const nonHexSha1 = '356g192b7913b04c54574d18c28d46e6395428ab'
-      const nonHexMd5 = '5g41402abc4b2a76b9719d911017c592'
-
-      expect(isHashedValue(nonHexSha256, 'sha256')).toBe(false)
-      expect(isHashedValue(nonHexSha1, 'sha1')).toBe(false)
-      expect(isHashedValue(nonHexMd5, 'md5')).toBe(false)
-    })
-
-    it('handles special characters correctly', () => {
-      const specialChars = '!@#$%^&*()_+-=[]{}|;:,.<>?/~`'
-      expect(isHashedValue(specialChars, 'sha256')).toBe(false)
-    })
-  })
-})

package/src/lib/index.js

@@ -1,14 +0,0 @@
-export * from './arrays/index.js'
-export * from './auth/index.js'
-export * from './checks.js'
-export * from './date/index.js'
-export * from './form/index.js'
-export * from './functions/index.js'
-export * from './hash.js'
-export * from './numbers/index.js'
-export * from './objects/index.js'
-export * from './promises/index.js'
-export * from './sse.js'
-export * from './strings/index.js'
-export * from './style/index.js'
-export * from './symbols/index.js'

package/src/lib/numbers/index.js

@@ -1,12 +0,0 @@
-export * from './math.js'
-
-export function splitUnit(string) {
-  // If there are no units, return the number straight.
-  if (typeof string === 'number') return [string, null]
-
-  const regex = /(-?\d*\.?\d+)\s*([a-z]+)/i
-  const match = string.match(regex)
-
-  if (match) return [parseFloat(match[1]), match[2]]
-  return [parseFloat(string), null] // sometimes unitless numbers make it here if was typed into a string. This catches and returns it.
-}

package/src/lib/numbers/math.js

@@ -1,9 +0,0 @@
-// Convert radians to degrees
-export function toDegrees(angle) {
-  return angle * (180 / Math.PI)
-}
-
-// Convert degrees to radians
-export function toRadians(angle) {
-  return angle * (Math.PI / 180)
-}

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

@@ -1,45 +0,0 @@
-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/camelcase-keys.js

@@ -1,17 +0,0 @@
-import { objectForEach } from './loop.js'
-import { toCamel } from '../strings/convert-case/convert-case.js'
-
-export function camelCaseKeys(obj) {
-  if (typeof obj !== 'object' || obj === null) {
-    return obj
-  }
-
-  const result = {}
-
-  objectForEach(obj, ({ key, value }) => {
-    const camelCaseKey = toCamel(key)
-    result[camelCaseKey] = camelCaseKeys(value)
-  })
-
-  return result
-}

package/src/lib/objects/camelcase-keys.test.js

@@ -1,72 +0,0 @@
-import { expect, it } from 'vitest'
-
-import { camelCaseKeys } from './camelcase-keys.js'
-
-it('Camelcase Basic', ctx => {
-  const object = {
-    lowercase: 1,
-    'Title Case': 2,
-    'kebab-case': 3,
-    PascalCase: 4,
-  }
-
-  const expected = {
-    lowercase: 1,
-    titleCase: 2,
-    kebabCase: 3,
-    pascalCase: 4,
-  }
-
-  const result = camelCaseKeys(object)
-  expect(result).toEqual(expected)
-})
-
-it('Camelcase Nested', ctx => {
-  const object = {
-    one: {
-      lowercase: 1,
-      'Title Case': 2,
-      'kebab-case': 3,
-      PascalCase: 4,
-    },
-  }
-
-  const expected = {
-    one: {
-      lowercase: 1,
-      titleCase: 2,
-      kebabCase: 3,
-      pascalCase: 4,
-    },
-  }
-
-  const result = camelCaseKeys(object)
-  expect(result).toEqual(expected)
-})
-
-it('Camelcase Deeply Nested', ctx => {
-  const object = {
-    one: {
-      two: {
-        lowercase: 1,
-        'Title Case': 2,
-        'kebab-case': 3,
-        PascalCase: 4,
-      },
-    },
-  }
-
-  const expected = {
-    one: {
-      two: {
-        lowercase: 1,
-        titleCase: 2,
-        kebabCase: 3,
-        pascalCase: 4,
-      },
-    },
-  }
-
-  const result = camelCaseKeys(object)
-  expect(result).toEqual(expected)
-})

package/src/lib/objects/empty.js

@@ -1,10 +0,0 @@
-export function isEmpty(obj) {
-  if (typeof obj === 'undefined') return true
-  if (obj === null) return true
-  if (Array.isArray(obj)) return obj.length === 0
-  return Object.keys(obj).length === 0
-}
-
-export function notEmpty(obj) {
-  return !isEmpty(obj)
-}

package/src/lib/objects/equal.js

@@ -1,9 +0,0 @@
-import deepEqual from 'deep-eql'
-
-export function isEqual(a, b) {
-  return deepEqual(a, b)
-}
-
-export function notEqual(a, b) {
-  return !isEqual(a, b)
-}

package/src/lib/objects/extend.js

@@ -1,16 +0,0 @@
-import { objectForEach, objectMap } from './loop.js'
-
-import { curry } from '../functions/functional.js'
-import { mix } from './mix/mix.js'
-
-// Need to manually curry these functions.
-
-export function extendObject(object) {
-  const orig = object
-  const extended = mix({}, object)
-
-  extended.forEach = curry(objectForEach)(orig)
-  extended.map = curry(objectMap)(orig)
-
-  return { orig, extended }
-}

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

@@ -1,35 +0,0 @@
-import { beforeEach, expect, it } from 'vitest'
-
-import { extendObject } from '.'
-
-beforeEach(ctx => {
-  ctx.object = {
-    one: 1,
-    two: 2,
-  }
-})
-
-it('Object Extension', ctx => {
-  const { object } = ctx
-  const { extended, orig } = extendObject(object)
-
-  // Orig should be untouched
-  // Object should also be untouched
-  expect(object).toEqual(orig)
-  expect(object.forEach).toBeUndefined()
-  expect(object.map).toBeUndefined()
-
-  // Extended should be extended
-  expect(extended.one).toBe(1)
-  expect(extended.two).toBe(2)
-  expect(extended.forEach).toBeDefined()
-  expect(extended.map).toBeDefined()
-})
-
-it('Curried methods', ctx => {
-  const { extended } = extendObject(ctx.object)
-
-  // Extended methods should not be part of the object when looping
-  const test = extended.map(({ key, value }) => value)
-  expect(test).toEqual([1, 2])
-})

package/src/lib/objects/flatten.js

@@ -1,19 +0,0 @@
-import { isObject } from '../checks.js'
-
-export function flattenObject(obj, { separator, prefix = '' }) {
-  return Object.entries(obj).reduce((acc, [key, value]) => {
-    const newKey = prefix ? `${prefix}${separator}${key}` : key
-
-    const isAnObject = isObject(value)
-    const hasNestedObject = isAnObject && Object.values(value).some(isObject)
-
-    if (hasNestedObject) {
-      // If the value is an object, recursively flatten it.
-      Object.assign(acc, flattenObject(value, { separator, prefix: newKey }))
-    } else {
-      // Directly assign terminal values to the new key in the accumulator.
-      acc[newKey] = value
-    }
-    return acc
-  }, {})
-}

package/src/lib/objects/index.js

@@ -1,13 +0,0 @@
-export * from './camelcase-keys.js'
-export * from './empty.js'
-export * from './equal.js'
-export * from './extend.js'
-export * from './flatten.js'
-export * from './json.js'
-export * from './loop.js'
-export * from './mix/mix.js'
-export * from './nested-property.js'
-export * from './normalize-object.js'
-export * from './omit-empty.js'
-export * from './size.js'
-export * from './split.js'

package/src/lib/objects/json.js

@@ -1,7 +0,0 @@
-export function parseJSON(value, defaultValue = {}) {
-  try {
-    return JSON.parse(value)
-  } catch (e) {
-    return defaultValue
-  }
-}

package/src/lib/objects/loop.js

@@ -1,11 +0,0 @@
-export function objectForEach(object, callback) {
-  Object.entries(object).forEach(([key, value]) => {
-    callback({ key, value })
-  })
-}
-
-export function objectMap(object, callback) {
-  return Object.entries(object).map(([key, value]) => {
-    return callback({ key, value })
-  })
-}

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

@@ -1,31 +0,0 @@
-import { beforeEach, expect, it } from 'vitest'
-import { objectForEach, objectMap } from './loop.js'
-
-beforeEach(ctx => {
-  ctx.obj = {
-    one: 1,
-    two: 2,
-  }
-})
-
-it('Object For Each', ctx => {
-  const { obj } = ctx
-  const newObject = {}
-  function callback({ key, value }) {
-    newObject[key] = value
-  }
-
-  objectForEach(obj, callback)
-  expect(newObject).toEqual(obj)
-})
-
-it('Object Map', ctx => {
-  const { obj } = ctx
-
-  function callback({ key, value }) {
-    return value
-  }
-
-  const res = objectMap(obj, callback)
-  expect(res).toEqual([1, 2])
-})