@splendidlabz/utils 1.11.2 → 1.11.4

package/src/lib/form/sanitize.js

@@ -1,80 +0,0 @@
-/**
- * @typedef {Object} SanitizeOptions
- * @property {Function} [sanitizer] - Function to sanitize strings
- * @property {*} [additional] - Any additional properties are passed through to the sanitizer function
- */
-
-/**
- * Core sanitization function that handles different value types.
- * Throws if no sanitizer function is provided.
- * Any additional properties in options are passed through to the sanitizer function.
- * 
- * @param {*} value - The value to sanitize
- * @param {SanitizeOptions} [options={}] - Sanitization options
- * @throws {Error} If sanitizer function is not provided
- * @returns {*} Sanitized value
- * @example
- * // Basic sanitization
- * sanitize('hello', { sanitizer: str => str.trim() })
- * 
- * // With additional options passed to sanitizer
- * sanitize('hello', { 
- *   sanitizer: (str, length, char) => str.padEnd(length, char),
- *   length: 10,
- *   char: '-'
- * })
- */
-export function sanitize(value, options = {}) {
-  const { sanitizer, ...rest } = options
-  if (!sanitizer) throw new Error('sanitizer function is required')
-
-  if (typeof value === 'string') return sanitizer(value, rest)
-  if (Array.isArray(value)) return sanitizeArray(value, { sanitizer, ...rest })
-  if (value && typeof value === 'object') {
-    return Object.fromEntries(
-      Object.entries(value).map(([key, val]) => [
-        key,
-        sanitize(val, { sanitizer, ...rest }),
-      ]),
-    )
-  }
-  return value
-}
-/**
- * Sanitizes an array by recursively sanitizing each element.
- * Throws if no sanitizer function is provided.
- * Any additional properties in options are passed through to the sanitizer function.
- * 
- * @param {Array} arr - Array to sanitize
- * @param {SanitizeOptions} options - Sanitization options
- * @throws {Error} If sanitizer function is not provided
- * @returns {Array} New array with sanitized values
- */
-function sanitizeArray(arr, { sanitizer, ...rest }) {
-  if (!sanitizer) throw new Error('sanitizer function is required')
-  return arr.map(item => sanitize(item, { sanitizer, ...rest }))
-}
-
-/**
- * Sanitizes all string values in an object recursively.
- * Throws if no sanitizer function is not provided.
- * Any additional properties in options are passed through to the sanitizer function.
- * 
- * @param {Object} obj - Object to sanitize
- * @param {SanitizeOptions} [options={}] - Sanitization options
- * @throws {Error} If sanitizer function is not provided
- * @returns {Object} New object with sanitized values
- */
-function sanitizeObject(obj, { sanitizer, ...options } = {}) {
-  if (!sanitizer) throw new Error('sanitizer function is required')
-  if (Array.isArray(obj)) return sanitizeArray(obj, { sanitizer, ...options })
-
-  return Object.fromEntries(
-    Object.entries(obj).map(([key, value]) => [
-      key,
-      sanitize(value, { sanitizer, ...options }),
-    ]),
-  )
-}
-
-export { sanitizeArray, sanitizeObject }

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/callback.js

@@ -1,8 +0,0 @@
-/**
- * Safely executes a callback function if it's a function
- * @param {Function|*} fn - The potential callback function
- * @param {...*} data - Data arguments to pass to the callback
- */
-export function runCallback(fn, ...data) {
-  if (typeof fn === 'function') fn(data)
-}

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.js

@@ -1,113 +0,0 @@
-/**
- * Creates a curried version of a function that can be called with partial arguments
- * @param {Function} fn - The function to curry
- * @return {Function} The curried function
- * @property {any} return - The result of calling the original function when all arguments are provided
- * @example
- * const add = (a, b, c) => a + b + c
- * const curriedAdd = curry(add)
- * curriedAdd(1)(2)(3) // 6
- * curriedAdd(1, 2)(3) // 6
- * curriedAdd(1)(2, 3) // 6
- */
-export function curry(fn) {
-  return function curried(...args) {
-    if (args.length >= fn.length) {
-      return fn.apply(this, args)
-    } else {
-      return function (...moreArgs) {
-        return curried.apply(this, args.concat(moreArgs))
-      }
-    }
-  }
-}
-
-/**
- * Composes functions from right to left (synchronous)
- * @param {...Function} fns - Functions to compose
- * @return {Function} The composed function
- * @property {any} return - The result of applying all functions in sequence
- * @example
- * const add1 = x => x + 1
- * const multiply2 = x => x * 2
- * const composed = compose(add1, multiply2)
- * composed(3) // 7 (3 * 2 + 1)
- */
-export function compose(...fns) {
-  return function (value) {
-    return fns.reduceRight((acc, fn) => fn(acc), value)
-  }
-}
-
-/**
- * Composes functions from right to left (asynchronous)
- * @param {...Function} fns - Functions to compose (can be sync or async)
- * @return {Function} The composed async function
- * @property {Promise<any>} return - A Promise that resolves to the result of applying all functions
- * @example
- * const add1 = x => x + 1
- * const multiplyAsync = async x => x * 2
- * await composeAsync(add1, multiplyAsync)(3) // 7 (3 * 2 + 1)
- */
-export function composeAsync(...fns) {
-  return async function (value) {
-    return fns.reduceRight(async (acc, fn) => {
-      const result = await acc
-      return await fn(result)
-    }, value)
-  }
-}
-
-/**
- * Pipes functions from left to right (synchronous)
- * @param {...Function} fns - Functions to pipe
- * @return {Function} The piped function
- * @property {any} return - The result of applying all functions in sequence
- * @example
- * const add1 = x => x + 1
- * const multiply2 = x => x * 2
- * const piped = pipe(add1, multiply2)
- * piped(3) // 8 (3 + 1) * 2
- */
-export function pipe(...fns) {
-  return function (value) {
-    return fns.reduce((acc, fn) => fn(acc), value)
-  }
-}
-
-/**
- * Pipes functions from left to right (asynchronous)
- * @param {...Function} fns - Functions to pipe (can be sync or async)
- * @return {Function} The piped async function
- * @property {Promise<any>} return - A Promise that resolves to the result of applying all functions
- * @example
- * const add1 = x => x + 1
- * const multiplyAsync = async x => x * 2
- * await pipeAsync(add1, multiplyAsync)(3) // 8 ((3 + 1) * 2)
- */
-export function pipeAsync(...fns) {
-  return async function (value) {
-    return fns.reduce(async (acc, fn) => {
-      const result = await acc
-      return await fn(result)
-    }, value)
-  }
-}
-
-/**
- * Calls a function n times with the current index and returns an array of results
- * @param {Function} fn - Function to call (receives index as argument)
- * @param {number} n - Number of times to call the function
- * @return {any[]} Array of results from calling the function
- * @property {any[]} return - Array containing the results of each function call
- * @example
- * times(i => i * 2, 3) // [0, 2, 4]
- * times(() => Math.random(), 2) // [0.123, 0.456] (random values)
- */
-export function times(fn, n) {
-  const result = []
-  for (let i = 0; i < n; i++) {
-    result.push(fn(i))
-  }
-  return result
-}

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

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