@splendidlabz/utils 1.11.3 → 1.11.4

package/src/dom/query-params.js

@@ -1,14 +0,0 @@
-// ========================
-// Query Params
-// ========================
-export const queryParams = {
-  get(key) {
-    const searchParams = new URLSearchParams(location.search)
-    return searchParams.get(key)
-  },
-
-  stringify(params) {
-    const searchParams = new URLSearchParams(location.search)
-    return searchParams.toString()
-  },
-}

package/src/dom/random-string.js

@@ -1,18 +0,0 @@
-/**
- * Generates a random string.
- * Ensures first character is a letter so it can be used in HTML ids and classes
- * This can actually be used everywhere, not just in the browser.
- */
-export function randomString(length = 10) {
-  const firstLetter = String.fromCharCode(65 + Math.floor(Math.random() * 26))
-  const others = Math.random()
-    .toString(36)
-    .substring(2, 2 + length - 1)
-
-  return firstLetter + others
-}
-
-// For browsers only
-export function uuid() {
-  return crypto.randomUUID()
-}

package/src/dom/random-string.test.js

@@ -1,13 +0,0 @@
-import { describe, expect, it } from 'vitest'
-import { randomString } from './random-string.js'
-
-describe('randomString', () => {
-  it('should generate a random string', () => {
-    const str = randomString()
-    expect(str).toBeDefined()
-    expect(str.length).toBe(10)
-
-    // Ensure the first character is a letter
-    expect(str[0]).toMatch(/[a-zA-Z]/)
-  })
-})

package/src/dom/sanitize.js

@@ -1,16 +0,0 @@
-import DOMPurify from 'dompurify'
-import { sanitize as sanitizeLib } from '../lib/form/sanitize.js'
-
-// Need to test if possible.
-// We can't test browser on node. So, unless we do like playwright or some form of browser testing, we can't actually verify this works every time.
-// Node version works already.
-/**
- * Sanitizes values using DOMPurify
- * @param {*} value - Value to sanitize (string, array, or object)
- * @param {Object} [options={}] - DOMPurify options
- * @returns {*} Sanitized value
- * @throws {Error} If input is a string but DOMPurify fails
- */
-export function sanitize(value, options = {}) {
-  return sanitizeLib(value, { sanitizer: DOMPurify.sanitize, ...options })
-}

package/src/dom/session-store.js

@@ -1,29 +0,0 @@
-// ========================
-// Session Storage
-// ========================
-export const sessionStore = {
-  get(key) {
-    const value = sessionStorage.getItem(key)
-    if (!value) return
-
-    try {
-      // Returns an object if stored value is JSON
-      return JSON.parse(value)
-    } catch (error) {
-      // Returns plain string if stored value is not JSON
-      return value
-    }
-  },
-
-  set(key, value) {
-    if (typeof value === 'string') {
-      sessionStorage.setItem(key, value)
-    } else {
-      sessionStorage.setItem(key, JSON.stringify(value))
-    }
-  },
-
-  remove(key) {
-    sessionStorage.removeItem(key)
-  },
-}

package/src/dom/spam-prevention.js

@@ -1,40 +0,0 @@
-/**
- * Enhances a form element with spam detection capabilities
- * @param {HTMLFormElement} form - The form element to enhance
- * @param {Object} [options] - Configuration options
- * @param {string} [options.honeypotField] - Name of the honeypot field (default: 'hp')
- * @param {number} [options.honeypotDuration] - Minimum time in ms for legitimate form fill (default: 2000)
- * @returns {void}
- */
-export function preventSpam(
-  form,
-  { honeypotField = 'hp', honeypotDuration = 2000 } = {},
-) {
-  const startTime = Date.now()
-  let hasInteraction = false
-
-  function checkForInteraction() {
-    hasInteraction = true
-  }
-
-  const events = ['keydown', 'mousemove', 'touchstart', 'click']
-  events.forEach(event => {
-    form.addEventListener(event, checkForInteraction, { once: true })
-  })
-
-  form.containsSpam = function () {
-    const fillTime = Date.now() - startTime
-    const isTooFast = fillTime < honeypotDuration
-    /** @type {HTMLInputElement | null} */
-    const honeypotInput = form.querySelector(`[name="${honeypotField}"]`)
-    const hasHoneypotValue = honeypotInput?.value?.trim()
-    const noInteraction = !hasInteraction
-
-    // Clean up event listeners after use
-    events.forEach(event =>
-      form.removeEventListener(event, checkForInteraction),
-    )
-
-    return isTooFast || !!hasHoneypotValue || noInteraction
-  }
-}

package/src/dom/trap-focus.js

@@ -1,70 +0,0 @@
-import { getFocusableElements } from './focusable.js'
-import { isShiftTab, isTab } from './keyboard.js'
-
-/**
- * Traps focus within a set of focusable elements, creating a circular tab order
- * @param {Object} params
- * @param {KeyboardEvent} params.event - The keyboard event to handle
- * @param {import('./focusable.js').Focusables} params.focusables - Object containing focusable elements
- */
-export function trapFocus({ event, focusables }) {
-  if (event.key !== 'Tab') return
-  if (isTab(event) && document.activeElement === focusables.last) {
-    event.preventDefault()
-    focusables.first.focus()
-  }
-
-  // User presses shift + tab from the first focusable element.
-  // Redirects to the last focusable element.
-  if (isShiftTab(event) && document.activeElement === focusables.first) {
-    event.preventDefault()
-    focusables.last.focus()
-  }
-}
-
-/**
- * Manages focus behavior when tabbing through content, with options to control focus on exit
- * @param {Object} params
- * @param {KeyboardEvent} params.event - The keyboard event to handle
- * @param {HTMLElement} params.triggerNode - Element that triggered the focus trap
- * @param {HTMLElement} params.contentNode - Container element that holds focusable content
- * @param {import('./focusable.js').Focusables} params.focusables - Object containing focusable elements
- * @param {'next'|'trigger'} [params.tabOutFocus='next'] - Where to focus when tabbing out: 'next' element or back to trigger
- * @param {Function} [params.onLeave=()=>{}] - Callback when focus leaves content, receives 'forward' or 'back' direction
- */
-export function manageFocus({
-  event,
-  triggerNode,
-  contentNode,
-  focusables,
-  tabOutFocus = 'next', // 'trigger'
-  onLeave = function () {},
-}) {
-  const activeEl = document.activeElement
-
-  if (activeEl === contentNode && isShiftTab(event)) return backFocus()
-  if (activeEl === contentNode && focusables.length === 0 && isTab(event))
-    return nextFocus()
-
-  if (activeEl === focusables.last && isTab(event)) return nextFocus()
-  if (activeEl === focusables.first && isShiftTab(event)) return backFocus()
-
-  function backFocus() {
-    event.preventDefault()
-    triggerNode.focus()
-    onLeave('back')
-  }
-
-  function nextFocus() {
-    if (tabOutFocus === 'trigger') triggerNode.focus()
-    if (tabOutFocus === 'next') {
-      event.preventDefault()
-      const DOMFocusables = getFocusableElements().keyboard
-      const index = DOMFocusables.findIndex(e => e === triggerNode)
-      const next = DOMFocusables[index + 1]
-      if (next) next.focus()
-      else triggerNode.focus()
-    }
-    onLeave('forward')
-  }
-}

package/src/dom/ui/aria-current.js

@@ -1,20 +0,0 @@
-export function markActiveAnchorIn(container, anchorType = 'page') {
-  if (!container) return
-
-  const { pathname } = window.location
-  const element = container.querySelector(`[href="${pathname}"]`)
-  if (!element) return
-
-  // Mark the active element
-  element.setAttribute('aria-current', 'page')
-  return element
-}
-
-export function scrollToElement(
-  element,
-  { scrollBehaviour = 'instant', scrollMargin = '3rem' } = {},
-) {
-  if (!element) return
-  element.style.scrollMarginTop = scrollMargin
-  element.scrollIntoView({ behavior: scrollBehaviour })
-}

package/src/dom/ui/index.js

@@ -1,4 +0,0 @@
-export * from './aria-current.js'
-export * from './inconsistent-button-fix.js'
-export * from './scroll-container.js'
-export * from './traverse-and-scramble.js'

package/src/dom/ui/scroll-container.js

@@ -1,25 +0,0 @@
-export function findScrollContainer(element, direction = 'both') {
-  if (!element) return
-
-  let parent = element.parentElement
-  while (parent) {
-    const { overflow, overflowX, overflowY } = getComputedStyle(parent)
-
-    if (direction === 'both') {
-      if (overflow.includes('auto') || overflow.includes('scroll'))
-        return parent
-    }
-
-    if (direction === 'horizontal') {
-      if (overflowX === 'auto' || overflowX === 'scroll') return parent
-    }
-
-    if (direction === 'vertical') {
-      if (overflowY === 'auto' || overflowY === 'scroll') return parent
-    }
-
-    parent = parent.parentElement
-  }
-
-  return document.documentElement
-}

package/src/dom/ui/traverse-and-scramble.js

@@ -1,61 +0,0 @@
-/**
- * Traverses a DOM node and scrambles its text content, excluding specified elements.
- * Useful for creating placeholder/loading states or privacy features.
- * 
- * @param {Element|ChildNode} node - The root element or node to start traversal from
- * @param {Object} [options] - Options for traversal
- * @param {string[]} [options.excludes=[]] - Array of CSS selectors to exclude from scrambling
- * @example
- * // Scramble all text in a container
- * traverseAndScramble(document.querySelector('.container'))
- * 
- * // Scramble text but exclude certain elements
- * traverseAndScramble(document.body, {
- *   excludes: ['.no-scramble', '[data-no-scramble]']
- * })
- */
-export function traverseAndScramble(node, { excludes = [] } = {}) {
-  // Check if the current node matches any of the exclude selectors
-  if (node instanceof Element && excludes.some(selector => node.matches(selector))) {
-    return // Skip this node and its children
-  }
-
-  node.childNodes.forEach(child => {
-    if (child.nodeType === 3) {
-      // Node.TEXT_NODE
-      child.nodeValue = scrambleText(child.nodeValue)
-    } else if (child.nodeType === 1 && child instanceof Element) {
-      // Node.ELEMENT_NODE
-      traverseAndScramble(child, { excludes }) // Recurse into child elements with excludes
-    }
-  })
-}
-
-/**
- * Scrambles text by replacing alphanumeric characters with random ones.
- * Preserves case, punctuation, and other symbols.
- * 
- * @param {string} text - The text to scramble
- * @returns {string} The scrambled text
- * @private
- * @example
- * scrambleText('Hello123!') // Returns something like 'Xk9mP2q!'
- */
-function scrambleText(text) {
-  return text
-    .split('')
-    .map(char => {
-      if (/^[A-Za-z0-9]$/.test(char)) {
-        const randomCharCode =
-          Math.random() < 26 / 36
-            ? Math.floor(Math.random() * 26) +
-              (char === char.toUpperCase() ? 65 : 97) // A-Z
-            : Math.floor(Math.random() * 10) + 48 // 0-9
-        return String.fromCharCode(randomCharCode)
-      } else {
-        // Keep punctuations and other symbols intact
-        return char
-      }
-    })
-    .join('')
-}

package/src/lib/arrays/index.js

@@ -1,6 +0,0 @@
-export * from './item-position.js'
-export * from './join.js'
-export * from './shuffle.js'
-export * from './sort.js'
-export * from './split-array.js'
-export * from './unique.js'

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
-}