@splendidlabz/utils 1.11.3 → 1.11.4

package/src/lib/checks.js

@@ -1,57 +0,0 @@
-/**
- * Checks if a value is a plain object (not an array or null)
- * @param {unknown} x - The value to check
- * @returns {boolean} True if the value is a plain object
- * @example
- * isObject({}) // true
- * isObject([]) // false
- * isObject(null) // false
- */
-export function isObject(x) {
-  return typeof x === 'object' && !Array.isArray(x) && x !== null
-}
-
-/**
- * Checks if a value is an array
- * @param {unknown} x - The value to check
- * @returns {boolean} True if the value is an array
- * @example
- * isArray([]) // true
- * isArray({}) // false
- */
-export function isArray(x) {
-  return Array.isArray(x)
-}
-
-/**
- * Checks if a value is not a plain object
- * @param {unknown} x - The value to check
- * @returns {boolean} True if the value is not a plain object
- * @example
- * notObject([]) // true
- * notObject(null) // true
- * notObject({}) // false
- */
-export function notObject(x) {
-  return !isObject(x)
-}
-
-export function getType(x) {
-  if (typeof x === 'string') return 'string'
-  if (typeof x === 'number') {
-    if (Number.isInteger(x)) return 'integer'
-    return 'float'
-  }
-  if (typeof x === 'boolean') return 'boolean'
-  if (typeof x === 'function') return 'function'
-  if (typeof x === 'undefined') return 'undefined'
-  if (typeof x === 'symbol') return 'symbol'
-  if (typeof x === 'bigint') return 'bigint'
-  if (Array.isArray(x)) return 'array'
-  if (typeof x === 'object') return 'object'
-  return 'unknown'
-}
-
-export function isFunction(x) {
-  return typeof x === 'function'
-}

package/src/lib/date/days.js

@@ -1,9 +0,0 @@
-export const DAYS = [
-  { short: 'Sun', long: 'Sunday', numeric: 1 },
-  { short: 'Mon', long: 'Monday', numeric: 2 },
-  { short: 'Tue', long: 'Tuesday', numeric: 3 },
-  { short: 'Wed', long: 'Wednesday', numeric: 4 },
-  { short: 'Thu', long: 'Thursday', numeric: 5 },
-  { short: 'Fri', long: 'Friday', numeric: 6 },
-  { short: 'Sat', long: 'Saturday', numeric: 7 },
-]

package/src/lib/date/index.js

@@ -1,3 +0,0 @@
-export * from './days.js'
-export * from './months.js'
-export * from './time.js'

package/src/lib/date/months.js

@@ -1,74 +0,0 @@
-export const MONTHS = [
-  {
-    long: 'January',
-    short: 'jan',
-    numeric: 1,
-    lastDay: { default: 31, leapYear: 31 },
-  },
-  {
-    long: 'February',
-    short: 'feb',
-    numeric: 2,
-    lastDay: { default: 28, leapYear: 29 },
-  },
-  {
-    long: 'March',
-    short: 'mar',
-    numeric: 3,
-    lastDay: { default: 31, leapYear: 31 },
-  },
-  {
-    long: 'April',
-    short: 'apr',
-    numeric: 4,
-    lastDay: { default: 30, leapYear: 30 },
-  },
-  {
-    long: 'May',
-    short: 'may',
-    numeric: 5,
-    lastDay: { default: 31, leapYear: 31 },
-  },
-  {
-    long: 'June',
-    short: 'jun',
-    numeric: 6,
-    lastDay: { default: 30, leapYear: 30 },
-  },
-  {
-    long: 'July',
-    short: 'jul',
-    numeric: 7,
-    lastDay: { default: 31, leapYear: 31 },
-  },
-  {
-    long: 'August',
-    short: 'aug',
-    numeric: 8,
-    lastDay: { default: 31, leapYear: 31 },
-  },
-  {
-    long: 'September',
-    short: 'sep',
-    numeric: 9,
-    lastDay: { default: 30, leapYear: 30 },
-  },
-  {
-    long: 'October',
-    short: 'oct',
-    numeric: 10,
-    lastDay: { default: 31, leapYear: 31 },
-  },
-  {
-    long: 'November',
-    short: 'nov',
-    numeric: 11,
-    lastDay: { default: 30, leapYear: 30 },
-  },
-  {
-    long: 'December',
-    short: 'dec',
-    numeric: 12,
-    lastDay: { default: 31, leapYear: 31 },
-  },
-]

package/src/lib/date/time.js

@@ -1,83 +0,0 @@
-import { splitUnit } from '../numbers/index.js'
-
-/**
- * Convert a time string to milliseconds
- * @param {string} arg - The time string to convert
- * @returns {number}
- */
-export function ms(arg) {
-  const [value, unit] = splitUnit(arg)
-  if (unit === 'd') return getTimeInMs(value, 'days')
-  if (unit === 'day') return getTimeInMs(value, 'days')
-  if (unit === 'days') return getTimeInMs(value, 'days')
-  if (unit === 'h') return getTimeInMs(value, 'hours')
-  if (unit === 'hr') return getTimeInMs(value, 'hours')
-  if (unit === 'hour') return getTimeInMs(value, 'hours')
-  if (unit === 'hours') return getTimeInMs(value, 'hours')
-  if (unit === 'm') return getTimeInMs(value, 'minutes')
-  if (unit === 'min') return getTimeInMs(value, 'minutes')
-  if (unit === 'mins') return getTimeInMs(value, 'minutes')
-  if (unit === 'minute') return getTimeInMs(value, 'minutes')
-  if (unit === 'minutes') return getTimeInMs(value, 'minutes')
-  if (unit === 's') return getTimeInMs(value, 'seconds')
-  if (unit === 'sec') return getTimeInMs(value, 'seconds')
-  if (unit === 'secs') return getTimeInMs(value, 'seconds')
-  if (unit === 'second') return getTimeInMs(value, 'seconds')
-  if (unit === 'seconds') return getTimeInMs(value, 'seconds')
-
-  // The rest are for milliseconds
-  return value
-}
-
-export function getTimeInMs(value, unit = 'ms') {
-  switch (unit) {
-    case 'ms':
-      return value
-    case 'seconds':
-      return value * 1000
-    case 'minutes':
-      return value * 1000 * 60
-    case 'hours':
-      return value * 1000 * 60 * 60
-    case 'days':
-      return value * 1000 * 60 * 60 * 24
-    case 'weeks':
-      return value * 1000 * 60 * 60 * 24 * 7
-  }
-}
-
-export function toWeeks(ms) {
-  return ms / 1000 / 60 / 60 / 24 / 7
-}
-
-export function toDays(ms) {
-  return ms / 1000 / 60 / 60 / 24
-}
-
-export function toHours(ms) {
-  return ms / 1000 / 60 / 60
-}
-
-export function toMinutes(ms) {
-  return ms / 1000 / 60
-}
-
-export function toSeconds(ms) {
-  return ms / 1000
-}
-
-// Get the total number of weeks, days, hours, minutes, and seconds
-export function toReadableTime(ms) {
-  const weekMs = 1000 * 60 * 60 * 24 * 7
-  const dayMs = 1000 * 60 * 60 * 24
-  const hourMs = 1000 * 60 * 60
-  const minuteMs = 1000 * 60
-
-  const weeks = Math.floor(ms / weekMs)
-  const days = Math.floor((ms % weekMs) / dayMs)
-  const hours = Math.floor((ms % dayMs) / hourMs)
-  const minutes = Math.floor((ms % hourMs) / minuteMs)
-  const seconds = Math.floor((ms % minuteMs) / 1000)
-
-  return { weeks, days, hours, minutes, seconds }
-}

package/src/lib/form/form-data.js

@@ -1,73 +0,0 @@
-/**
- * Converts Form Data into an object
- * @param {FormData} formData
- * @returns Object
- */
-export function formDataToObject(formData) {
-  const obj = {}
-  for (let [key, value] of formData) {
-    if (typeof value === 'string') value = value.trim()
-
-    if (key.includes('[]')) {
-      // Handle array fields
-      const arrayKey = key.replace('[]', '')
-      if (!obj[arrayKey]) obj[arrayKey] = []
-      obj[arrayKey].push(value)
-    } else {
-      // Handle normal string fields
-      obj[key] = value
-    }
-  }
-  return obj
-}
-
-export function flattenArrayFields(inputObject) {
-  const result = {}
-
-  for (const [key, value] of Object.entries(inputObject)) {
-    // Regex to match keys that follow pattern: arrayName[index][property]
-    const match = key.match(/^(\w+)(?:\[(\d+)\])?(?:\[(\w+)\])?$/)
-    if (match) {
-      const [, baseKey, index, property] = match
-
-      if (index !== undefined) {
-        // Handle array of objects
-        if (!result[baseKey]) result[baseKey] = []
-        const arrayIndex = parseInt(index)
-        if (!result[baseKey][arrayIndex]) result[baseKey][arrayIndex] = {}
-        if (property) {
-          result[baseKey][arrayIndex][property] = value
-        } else {
-          result[baseKey][arrayIndex] = value
-        }
-      } else if (property) {
-        // Handle single object
-        if (!result[baseKey]) result[baseKey] = {}
-        result[baseKey][property] = value
-      } else {
-        // Handle simple key-value
-        result[key] = value
-      }
-    } else {
-      // Copy key-value pair for unmatched keys
-      result[key] = value
-    }
-  }
-
-  // Remove empty objects from arrays and convert array-like objects to actual arrays
-  for (const key in result) {
-    if (typeof result[key] === 'object' && result[key] !== null) {
-      if (Object.keys(result[key]).every(k => !isNaN(parseInt(k)))) {
-        // Convert to array and filter out empty items
-        result[key] = Object.values(result[key]).filter(item => {
-          if (typeof item === 'object') {
-            return Object.values(item).some(v => v !== '')
-          }
-          return item !== ''
-        })
-      }
-    }
-  }
-
-  return result
-}

package/src/lib/form/index.js

@@ -1,2 +0,0 @@
-export * from './form-data.js'
-export * from './sanitize.js'

package/src/lib/form/sanitize.spec.js

@@ -1,126 +0,0 @@
-import sanitizeHtml from 'sanitize-html'
-import { describe, expect, it } from 'vitest'
-import { sanitize } from './sanitize.js'
-
-// Real sanitizer using sanitize-html
-function mockSanitizer(value, options = {}) {
-  if (typeof value !== 'string') return value
-  return sanitizeHtml(value, {
-    allowedTags: ['b', 'i', 'em', 'strong', 'a'],
-    allowedAttributes: {
-      a: ['href'],
-    },
-    ...options,
-  })
-}
-
-describe('sanitize', () => {
-  it('sanitizes HTML in string values', () => {
-    const input = {
-      name: '<script>alert("xss")</script>John',
-      bio: '<p>Hello <b>World</b> <script>alert("xss")</script></p>',
-      link: '<a href="javascript:alert(1)">Click me</a>',
-      safeLink: '<a href="https://example.com">Safe link</a>',
-    }
-
-    const expected = {
-      name: 'John',
-      bio: 'Hello <b>World</b> ',
-      link: '<a>Click me</a>',
-      safeLink: '<a href="https://example.com">Safe link</a>',
-    }
-
-    expect(sanitize(input, { sanitizer: mockSanitizer })).toEqual(expected)
-  })
-
-  it('sanitizes nested objects with HTML', () => {
-    const input = {
-      user: {
-        name: '<script>alert("xss")</script>John',
-        profile: {
-          bio: '<p>Hello <b>World</b></p>',
-          links: [
-            '<a href="javascript:alert(1)">Bad</a>',
-            '<a href="https://good.com">Good</a>',
-          ],
-        },
-      },
-    }
-
-    const expected = {
-      user: {
-        name: 'John',
-        profile: {
-          bio: 'Hello <b>World</b>',
-          links: ['<a>Bad</a>', '<a href="https://good.com">Good</a>'],
-        },
-      },
-    }
-
-    expect(sanitize(input, { sanitizer: mockSanitizer })).toEqual(expected)
-  })
-
-  it('preserves non-string values and sanitizes arrays correctly', () => {
-    const input = {
-      name: '<script>alert("xss")</script>John',
-      age: 25,
-      active: true,
-      email: null,
-      role: undefined,
-      tags: ['<script>alert(1)</script>admin', 'user'],
-      numbers: [1, 2, 3],
-      mixed: ['<b>bold</b>', 42, null, '<script>alert(1)</script>text'],
-    }
-
-    const expected = {
-      name: 'John',
-      age: 25,
-      active: true,
-      email: null,
-      role: undefined,
-      tags: ['admin', 'user'],
-      numbers: [1, 2, 3],
-      mixed: ['<b>bold</b>', 42, null, 'text'],
-    }
-
-    expect(sanitize(input, { sanitizer: mockSanitizer })).toEqual(expected)
-  })
-
-  it('throws error when sanitizer is not provided', () => {
-    const input = { name: '<script>alert(1)</script>John' }
-    expect(() => sanitize(input)).toThrow('sanitizer function is required')
-  })
-
-  it('allows custom sanitizer options', () => {
-    const input = {
-      content: '<p>Hello <span>World</span> <script>alert(1)</script></p>',
-    }
-
-    const defaultOptions = {
-      allowedTags: ['b', 'i', 'em', 'strong', 'a'],
-      allowedAttributes: {
-        a: ['href'],
-      },
-    }
-
-    // Test with custom allowed tags
-    const withSpan = sanitize(input, {
-      sanitizer: v =>
-        mockSanitizer(v, {
-          ...defaultOptions,
-          allowedTags: [...defaultOptions.allowedTags, 'span'],
-        }),
-    })
-    expect(withSpan.content).toBe('Hello <span>World</span> ')
-
-    // Test with no allowed tags
-    const noTags = sanitize(input, {
-      sanitizer: v =>
-        mockSanitizer(v, {
-          ...defaultOptions,
-          allowedTags: [],
-        }),
-    })
-    expect(noTags.content).toBe('Hello World ')
-  })
-})

package/src/lib/functions/debounce.js

@@ -1,18 +0,0 @@
-export function debounce(callback, wait, immediate = false) {
-  let timeout
-
-  return function () {
-    const context = this
-    const args = arguments
-
-    const callNow = immediate && !timeout
-    clearTimeout(timeout)
-    timeout = setTimeout(later, wait)
-    if (callNow) callback.apply(context, args)
-
-    function later() {
-      timeout = null
-      if (!immediate) callback.apply(context, args)
-    }
-  }
-}

package/src/lib/functions/env.js

@@ -1,5 +0,0 @@
-// Checks whether current environment is browser or node
-export function getEnv() {
-  if (typeof window === 'object') return 'browser'
-  if (typeof global === 'object') return 'node'
-}

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

@@ -1,196 +0,0 @@
-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/functions/index.js

@@ -1,5 +0,0 @@
-export * from './debounce.js'
-export * from './env.js'
-export * from './functional.js'
-export * from './throttle.js'
-export * from './timeout.js'

package/src/lib/functions/throttle.js

@@ -1,11 +0,0 @@
-export function throttle(callback, wait) {
-  let lastCall = 0
-
-  return function (...args) {
-    const now = new Date().getTime()
-    if (now - lastCall >= wait) {
-      callback(...args)
-      lastCall = now
-    }
-  }
-}

package/src/lib/functions/timeout.js

@@ -1,15 +0,0 @@
-// setTimeout for task ticking
-// reverses wait and callback functions of timeouts because it makes more sense when reading the code
-export function timeout(wait, callback) {
-  setTimeout(callback, wait)
-}
-
-// Promise based timeouts for microtask ticking
-export function delay(ms) {
-  return new Promise(resolve => setTimeout(resolve, ms))
-}
-
-// Alias of delay
-export function wait(ms) {
-  return delay(ms)
-}