@splendidlabz/utils 1.11.2 → 1.11.4

package/src/lib/arrays/item-position.js

@@ -1,23 +0,0 @@
-export function last(array, index) {
-  console.warn('last is deprecated. Use isLastItem instead.')
-  return index === array.length - 1
-}
-
-/**
- * Checks if the given index is the last item in the array
- * @param {Array} array - The array to check
- * @param {number} index - The index to check
- * @returns {boolean} True if the index is the last item, false otherwise
- */
-export function isLastItem(array, index) {
-  return index === array.length - 1
-}
-
-/**
- * Returns the last item in the array
- * @param {Array} array - The array to get the last item from
- * @returns {*} The last item in the array
- */
-export function lastArrayItem(array) {
-  return array[array.length - 1]
-}

package/src/lib/arrays/join.js

@@ -1,20 +0,0 @@
-import { lastArrayItem } from './item-position.js'
-/**
- * Joins an array with a conjunction (and/or)
- * @param {Array<string>} array - Array of strings to join
- * @param {Object} [options] - Options for joining
- * @param {string} [options.conjunction='and'] - Conjunction to use ('and' or 'or')
- * @returns {string} Joined string
- * @example
- * joinWithConjunction(['a', 'b', 'c']) // 'a, b, and c'
- * joinWithConjunction(['a', 'b'], { conjunction: 'or' }) // 'a or b'
- */
-export function joinWithConjunction(array, { conjunction = 'and' } = {}) {
-  if (!array?.length) return ''
-  if (array.length === 1) return array[0]
-  if (array.length === 2) return `${array[0]} ${conjunction} ${array[1]}`
-
-  const lastItem = lastArrayItem(array)
-  const rest = array.slice(0, -1)
-  return `${rest.join(', ')} ${conjunction} ${lastItem}`
-}

package/src/lib/arrays/shuffle.js

@@ -1,21 +0,0 @@
-// Fisher Yates Shuffle without mutating the original array
-export function shuffle(array) {
-  const clone = array.slice()
-  let currentIndex = array.length
-  let temporaryValue
-  let randomIndex
-
-  // While there remain elements to shuffle...
-  while (currentIndex !== 0) {
-    // Pick a remaining element...
-    randomIndex = Math.floor(Math.random() * currentIndex)
-    currentIndex -= 1
-
-    // And swap it with the current element.
-    temporaryValue = clone[currentIndex]
-    clone[currentIndex] = clone[randomIndex]
-    clone[randomIndex] = temporaryValue
-  }
-
-  return clone
-}

package/src/lib/arrays/sort.js

@@ -1,88 +0,0 @@
-import { getNestedValue } from '../objects/nested-property.js'
-
-/**
- * Sorts an array of objects, numbers, or strings without mutating the original array.
- * Supports nested properties, multiple sort keys, and various data types.
- *
- * @template T
- * @param {T[]} array - Array to sort
- * @param {Object} [options] - Sort options
- * @param {string|string[]|null} [options.props=null] - Property or array of properties to sort by. If null, sorts simple arrays
- * @param {boolean} [options.reverse=false] - Whether to sort in reverse order
- * @returns {T[]} New sorted array
- * @example
- * // Sort simple array
- * sort([3, 1, 2]) // [1, 2, 3]
- *
- * // Sort objects by single property
- * sort(users, { props: 'name' })
- *
- * // Sort objects by multiple properties
- * sort(users, { props: ['age', 'name'] })
- *
- * // Sort in reverse order
- * sort(users, { props: 'age', reverse: true })
- *
- * // Sort by nested property
- * sort(users, { props: 'address.city' })
- */
-export function sort(array, { props = null, reverse = false } = {}) {
-  const clone = array.slice()
-
-  // Handle simple arrays (numbers or strings)
-  if (props === null) {
-    return clone.sort((a, b) => {
-      const comparison = compareValues(a, b)
-      return reverse ? -comparison : comparison
-    })
-  }
-
-  // Handle objects in arrays
-  const properties = Array.isArray(props) ? props : [props]
-
-  return clone.sort((a, b) => {
-    for (const property of properties) {
-      const aValue = getNestedValue(a, property)
-      const bValue = getNestedValue(b, property)
-
-      // Skip if values are equal
-      if (aValue === bValue) continue
-
-      // Push null/undefined values to the end
-      if (aValue == null) return 1
-      if (bValue == null) return -1
-
-      // Compare values and handle reverse sort
-      const comparison = compareValues(aValue, bValue)
-      return reverse ? -comparison : comparison
-    }
-    return 0
-  })
-}
-
-/**
- * Compares two values for sorting, handling different data types.
- * Supports numbers, strings, dates, and falls back to string comparison.
- *
- * @param {*} a - First value to compare
- * @param {*} b - Second value to compare
- * @returns {number} -1 if a < b, 0 if a === b, 1 if a > b
- * @private
- */
-function compareValues(a, b) {
-  // Compare numbers
-  if (typeof a === 'number' && typeof b === 'number') return a - b
-
-  // Compare strings
-  if (typeof a === 'string' && typeof b === 'string') return a.localeCompare(b)
-
-  // Compare dates
-  const aDate = new Date(a)
-  const bDate = new Date(b)
-  const aTime = aDate.getTime()
-  const bTime = bDate.getTime()
-  if (!isNaN(aTime) && !isNaN(bTime)) return aTime - bTime
-
-  // Convert into strings and compare
-  return String(a).localeCompare(String(b))
-}

package/src/lib/arrays/sort.spec.js

@@ -1,123 +0,0 @@
-import { describe, expect, it } from 'vitest'
-
-import { sort } from './index.js'
-
-describe('Sort by', _ => {
-  it('Standard array - numbers', async () => {
-    const array = [3, 1, 2]
-    const sorted = sort(array)
-    const reversed = sort(array, { reverse: true })
-    expect(sorted).toEqual([1, 2, 3])
-    expect(reversed).toEqual([3, 2, 1])
-  })
-
-  it('Standard array - strings', async () => {
-    const array = ['c', 'a', 'b']
-    const sorted = sort(array)
-    const reversed = sort(array, { reverse: true })
-    expect(sorted).toEqual(['a', 'b', 'c'])
-    expect(reversed).toEqual(['c', 'b', 'a'])
-  })
-
-  it('Standard array - dates', async () => {
-    const array = [
-      new Date('2021-05-18'),
-      new Date('2022-01-01'),
-      new Date('2025-03-09'),
-    ]
-    const sorted = sort(array)
-    const reversed = sort(array, { reverse: true })
-    expect(sorted).toEqual([
-      new Date('2021-05-18'),
-      new Date('2022-01-01'),
-      new Date('2025-03-09'),
-    ])
-    expect(reversed).toEqual([
-      new Date('2025-03-09'),
-      new Date('2022-01-01'),
-      new Date('2021-05-18'),
-    ])
-  })
-  it('Array of objects — simple integer', async () => {
-    const array = [
-      { name: 'Ace', age: 30 },
-      { name: 'Betty', age: 25 },
-      { name: 'Candy', age: 35 },
-    ]
-    const sorted = sort(array, { props: 'age' })
-    const reversed = sort(array, { props: 'age', reverse: true })
-    expect(sorted).toEqual([
-      { name: 'Betty', age: 25 },
-      { name: 'Ace', age: 30 },
-      { name: 'Candy', age: 35 },
-    ])
-    expect(reversed).toEqual([
-      { name: 'Candy', age: 35 },
-      { name: 'Ace', age: 30 },
-      { name: 'Betty', age: 25 },
-    ])
-  })
-
-  it('Array of objects — simple string', async () => {
-    const array = [
-      { name: 'Ace', age: 30 },
-      { name: 'Betty', age: 25 },
-      { name: 'Candy', age: 35 },
-    ]
-    const sorted = sort(array, { props: 'name' })
-    const reversed = sort(array, { props: 'name', reverse: true })
-    expect(sorted).toEqual([
-      { name: 'Ace', age: 30 },
-      { name: 'Betty', age: 25 },
-      { name: 'Candy', age: 35 },
-    ])
-    expect(reversed).toEqual([
-      { name: 'Candy', age: 35 },
-      { name: 'Betty', age: 25 },
-      { name: 'Ace', age: 30 },
-    ])
-  })
-
-  it('Double property', async () => {
-    const array = [
-      { name: 'Ace', age: 30 },
-      { name: 'Betty', age: 25 },
-      { name: 'Candy', age: 35 },
-      { name: 'Danny', age: 30 },
-    ]
-    const sorted = sort(array, { props: ['age', 'name'] })
-    const reversed = sort(array, { props: ['age', 'name'], reverse: true })
-    expect(sorted).toEqual([
-      { name: 'Betty', age: 25 },
-      { name: 'Ace', age: 30 },
-      { name: 'Danny', age: 30 },
-      { name: 'Candy', age: 35 },
-    ])
-    expect(reversed).toEqual([
-      { name: 'Candy', age: 35 },
-      { name: 'Danny', age: 30 },
-      { name: 'Ace', age: 30 },
-      { name: 'Betty', age: 25 },
-    ])
-  })
-
-  it('Nested value', async () => {
-    const array = [
-      { data: { value: 1 } },
-      { data: { value: 2 } },
-      { data: { value: 3 } },
-    ]
-    const sorted = sort(array, { props: 'data.value' })
-    const reversed = sort(array, { props: 'data.value', reverse: true })
-    expect(sorted).toEqual([
-      { data: { value: 1 } },
-      { data: { value: 2 } },
-      { data: { value: 3 } },
-    ])
-    expect(reversed).toEqual([
-      { data: { value: 3 } },
-      { data: { value: 2 } },
-      { data: { value: 1 } },
-    ])
-  })
-})

package/src/lib/arrays/split-array.js

@@ -1,15 +0,0 @@
-export function splitArray(array, predicate) {
-  const ret = {
-    picked: [],
-    omitted: [],
-  }
-
-  array.forEach((item, index, arr) => {
-    if (predicate(item, index, arr)) ret.picked.push(item)
-    else ret.omitted.push(item)
-  })
-
-  ret.p = ret.picked
-  ret.o = ret.omitted
-  return ret
-}

package/src/lib/arrays/unique.js

@@ -1,3 +0,0 @@
-export function uniqueArray(array) {
-  return Array.from(new Set(array))
-}

package/src/lib/auth/index.js

@@ -1 +0,0 @@
-export * from './route-manager.js'

package/src/lib/auth/route-manager.js

@@ -1,45 +0,0 @@
-/**
-  // Usage ... Probably should use either protected or bypass, not both.
-  // Maybe ... glob would be a better for this
-  @example 
-  const config = {
-    routeConfig: {
-      startsWith: ['/dashboard']
-    }
-    bypassRoutes: {
-      is: ['/'],
-      startsWith: ['/fonts', '/auth', '/favicon', '/images'],
-      includes: ['/meh'],
-    }
-  }
-  const {isProtectedRoute, isBypassRoute} = AuthManager(config)
-  if (!isProtectedRoute(context.url.pathname)) return next() // Handle only protected routes
-  if (isBypassRoute(context.url.pathname)) return next() // Bypass all non protected routes
- */
-
-export function RouteManager(config) {
-  const { protectedRoutes, bypassRoutes } = config
-  return {
-    isProtectedRoute(pathname) {
-      return isMatch(protectedRoutes, pathname)
-    },
-    isBypassRoute(pathname) {
-      return isMatch(bypassRoutes, pathname)
-    },
-  }
-}
-
-// Alias for RouteManager
-export function AuthManager(config) {
-  return RouteManager(config)
-}
-
-function isMatch(routeConfig, pathname) {
-  const { is, startsWith, includes } = routeConfig
-  const isExactMatch = is && is.some(u => pathname === u)
-  const startsWithMatch =
-    startsWith && startsWith.some(u => pathname.startsWith(u))
-  const includesMatch = includes && includes.some(u => pathname.includes(u))
-
-  return isExactMatch || startsWithMatch || includesMatch
-}

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'