@splendidlabz/utils 1.5.0-alpha.4 → 1.5.0-beta.6

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @splendidlabz/utils
 
+## 1.5.0-beta.6
+
+### Minor Changes
+
+- Add utilities for SSE
+
+## 1.5.0-beta.5
+
+### Minor Changes
+
+- Ready for next release
+
 ## 1.5.0-alpha.4
 
 ### Patch Changes

package/dom/actions/prefer-horizontal-scroll.js

@@ -12,7 +12,7 @@ const DEFAULT_OPTIONS = {
 }
 
 export function preferHorizontalScroll(node, props = {}) {
-  if (!node.classList.contains('scrollable-prefer-horizontal-scroll')) return
+  if (!node.classList.contains('scrollable-prefer-horizontal')) return
 
   const state = {
     origSnapType: null,
@@ -23,7 +23,7 @@ export function preferHorizontalScroll(node, props = {}) {
   const options = {
     ...DEFAULT_OPTIONS,
     ...omitEmpty({
-      scrollSnapDelay: getCSSVar(node, '--scrollSnapDelay'),
+      scrollSnapDelay: getCSSVar(node, '--scroll-snap-delay'),
     }),
     ...omitEmpty(props),
   }

package/dom/index.js

@@ -16,6 +16,7 @@ export * from './observers/index.js'
 export * from './pkce.js'
 export * from './query-params.js'
 export * from './random-string.js'
+export * from './sanitize.js'
 export * from './session-store.js'
 export * from './trap-focus.js'
 export * from './ui/index.js'

package/dom/local-store.js

@@ -1,7 +1,17 @@
 // ========================
 // Local Storage
 // ========================
+
+/**
+ * Utility object for managing localStorage operations with JSON support
+ * @namespace localStore
+ */
 export const localStore = {
+  /**
+   * Retrieves a value from localStorage
+   * @param {string} key - The key to retrieve from localStorage
+   * @returns {any} The stored value. Returns parsed JSON if the value was stored as JSON. Returns the original string if not JSON, or undefined if key doesn't exist
+   */
   get(key) {
     const value = localStorage.getItem(key)
     if (!value) return
@@ -15,6 +25,11 @@ export const localStore = {
     }
   },
 
+  /**
+   * Stores a value in localStorage
+   * @param {string} key - The key to store the value under
+   * @param {any} value - The value to store. Objects will be stringified to JSON
+   */
   set(key, value) {
     if (typeof value === 'string') {
       localStorage.setItem(key, value)
@@ -23,7 +38,29 @@ export const localStore = {
     }
   },
 
+  /**
+   * Stores multiple key-value pairs in localStorage
+   * @param {Object|Map} data - An object or Map containing key-value pairs to store
+   */
+  setMultiple(data) {
+    for (const [key, value] of Object.entries(data)) {
+      this.set(key, value)
+    }
+  },
+
+  /**
+   * Removes a value from localStorage
+   * @param {string} key - The key to remove from localStorage
+   */
   remove(key) {
     localStorage.removeItem(key)
   },
+
+  /**
+   * Removes multiple keys from localStorage
+   * @param {string[]} keys - Array of keys to remove from localStorage
+   */
+  removeMultiple(keys) {
+    keys.forEach(key => this.remove(key))
+  },
 }

package/dom/observers/resize-observer.js

@@ -2,10 +2,40 @@
 import { dispatchEvent } from '../events.js'
 import { useObserverMethodOnTarget } from './observer.js'
 
+/**
+ * Creates and manages a ResizeObserver instance to monitor size changes of a target element.
+ * 
+ * @param {Element|Window|NodeList|Element[]} target - The element(s) to observe. 
+ *   - If window is provided, document.body will be observed instead.
+ *   - If NodeList or Array of elements is provided, all elements will be observed.
+ * @param {Object} options - Configuration options for the resize observer
+ * @param {boolean} [options.observe=true] - Whether to start observing immediately. If false, the observer won't be created.
+ * @param {Function} [options.callback] - Optional callback function that will be called when resize changes are detected.
+ *                                          If not provided, a 'resize-obs' event will be dispatched on the target.
+ * @param {Object} [options...] - Additional options to pass to ResizeObserver.observe()
+ * 
+ * @returns {Object} An object with methods to control the observer:
+ *   - observe(target, options): Start observing a new target element
+ *   - unobserve(target): Stop observing a target element
+ *   - disconnect(): Disconnect the observer and stop all observations
+ *   - destroy(): Alias for disconnect()
+ * 
+ * @example
+ * // Basic usage with callback
+ * resizeObserver(element, {
+ *   callback: ({ entry, entries, observer }) => {
+ *     console.log('Element resized:', entry.contentRect);
+ *   }
+ * });
+ * 
+ * @example
+ * // Usage with event listener
+ * resizeObserver(element);
+ * element.addEventListener('resize-obs', ({ detail }) => {
+ *   console.log('Element resized:', detail.entry.contentRect);
+ * });
+ */
 export function resizeObserver(target, options) {
-  // We set the option here to prevent observer from being created unless necessary.
-  options = { observe: true, ...options }
-  if (!options.observe) return
   const { callback, ...opts } = options
   const observer = new ResizeObserver(observerFn)
 

package/dom/sanitize.js

@@ -0,0 +1,16 @@
+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 })
+}

package/lib/arrays/index.js

@@ -1,85 +1,5 @@
-import { getNestedValue } from '../objects/nested-property.js'
-
-export function last(array, index) {
-  return index === array.length - 1
-}
-
-// 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
-}
-
-/**
- * Sorts an array of objects, numbers, or strings without mutating the original array
- * @param {Array} array - Array to sort
- * @param {Object} options - Sort options
- * @param {string|string[]|null} options.props - Property or array of properties to sort by. If null, sorts simple arrays
- * @param {boolean} options.reverse - Whether to sort in reverse order
- */
-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
-  })
-}
-
-// Compare values for sorting
-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)
-  if (!isNaN(aDate) && !isNaN(bDate)) return aDate.getTime() - bDate.getTime()
-
-  // Convert into strings and compare
-  return String(a).localeCompare(String(b))
-}
+export * from './item-position.js'
+export * from './join.js'
+export * from './shuffle.js'
+export * from './sort.js'
+export * from './unique.js'

package/lib/arrays/item-position.js

@@ -0,0 +1,23 @@
+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/lib/arrays/join.js

@@ -0,0 +1,17 @@
+import { lastArrayItem } from './item-position.js'
+/**
+ * Joins an array of strings with commas and a conjunction for the last item
+ * @param {string[]} array - Array of strings to join
+ * @param {Object} options - Join options
+ * @param {string} options.conjunction - Conjunction to use ('and' or 'or')
+ * @returns {string} Joined string
+ */
+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/lib/arrays/shuffle.js

@@ -0,0 +1,21 @@
+// 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/lib/arrays/sort.js

@@ -0,0 +1,58 @@
+import { getNestedValue } from '../objects/nested-property.js'
+/**
+ * Sorts an array of objects, numbers, or strings without mutating the original array
+ * @param {Array} array - Array to sort
+ * @param {Object} options - Sort options
+ * @param {string|string[]|null} options.props - Property or array of properties to sort by. If null, sorts simple arrays
+ * @param {boolean} options.reverse - Whether to sort in reverse order
+ */
+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
+  })
+}
+
+// Compare values for sorting
+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)
+  if (!isNaN(aDate) && !isNaN(bDate)) return aDate.getTime() - bDate.getTime()
+
+  // Convert into strings and compare
+  return String(a).localeCompare(String(b))
+}

package/lib/arrays/unique.js

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

package/lib/date/index.js

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

package/lib/date/time.js

@@ -0,0 +1,50 @@
+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 === '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 === 'second') return getTimeInMs(value, 'seconds')
+  if (unit === 'seconds') return getTimeInMs(value, 'seconds')
+
+  // The rest are for milliseconds
+  return value
+}
+
+export function seconds(arg) {
+  const value = ms(arg)
+  return value / 1000
+}
+
+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
+  }
+}

package/lib/form/sanitize.js

@@ -1,48 +1,57 @@
-import DOMPurify from 'dompurify'
-
-// MIGHT HAVE TO SHIFT THIS TO DOM, because DOMPurify doesn't work with Node
 /**
- * Sanitizes HTML string using DOMPurify.
- * @param {string} html - The HTML string to sanitize.
- * @param {Object} [options={}] - DOMPurify configuration options.
- * @returns {string} The sanitized HTML string.
+ * Core sanitization function that handles different value types
+ * @param {*} value - The value to sanitize
+ * @param {Object} [options={}] - Sanitization options
+ * @param {Function} options.sanitizer - Function to sanitize strings. Must be provided
+ * @returns {*} Sanitized value
  */
-export function sanitize(html, options = {}) {
-  return DOMPurify.sanitize(html, options)
-}
+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
+}
 /**
- * Recursively sanitizes entries in an object or array.
- * @param {Array} entries - The entries to sanitize.
- * @param {Object} [options={}] - DOMPurify configuration options.
- * @returns {Array} The sanitized entries.
+ * Sanitizes an array by recursively sanitizing each element
+ * @param {Array} arr - Array to sanitize
+ * @param {Object} options - Sanitization options
+ * @param {Function} options.sanitizer - Function to sanitize strings. Must be provided
+ * @returns {Array} New array with sanitized values
+ * @throws {Error} If sanitizer function is not provided
  */
-export function sanitizeEntries(entries, options = {}) {
-  return entries.map(([key, value]) => {
-    if (Array.isArray(value)) {
-      return [
-        key,
-        value.map(item => sanitizeEntries(Object.entries(item), options)),
-      ]
-    }
-
-    if (value && typeof value === 'object') {
-      return [
-        key,
-        Object.fromEntries(sanitizeEntries(Object.entries(value), options)),
-      ]
-    }
-
-    return [key, sanitize(value, options)]
-  })
+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.
- * @param {Object} obj - The object to sanitize.
- * @param {Object} [options={}] - DOMPurify configuration options.
- * @returns {Object} A new object with all string values sanitized.
+ * Sanitizes all string values in an object recursively
+ * @param {Object} obj - Object to sanitize
+ * @param {Object} [options={}] - Sanitization options
+ * @param {Function} options.sanitizer - Function to sanitize strings. Must be provided
+ * @returns {Object} New object with sanitized values
+ * @throws {Error} If sanitizer function is not provided
  */
-export function sanitizeObject(obj, options = {}) {
-  return Object.fromEntries(sanitizeEntries(Object.entries(obj), options))
+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/lib/form/sanitize.spec.js

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

@@ -7,6 +7,7 @@ export * from './functions/index.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/lib/objects/equal.js

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

package/lib/objects/index.js

@@ -1,5 +1,6 @@
 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'

package/lib/sse.js

@@ -0,0 +1,64 @@
+// Server Sent Events (SSE) 
+import { omitEmpty } from './objects/omit-empty.js'
+
+export function createSSE({ event, data, id, retry }) {
+  const eventString = event ? `event: ${event}\n` : ''
+  const idString = id ? `id: ${id}\n` : ''
+  const retryString = retry ? `retry: ${retry}\n` : ''
+  
+  if (typeof data === 'object') data = JSON.stringify(data)
+  const dataString = data ? `data: ${data}\n` : ''
+
+  return `${eventString}${dataString}${idString}${retryString}\n`
+}
+
+/**
+ * Parses a single SSE message into a structured object
+ * @param {string} message - The raw SSE message
+ * @returns {Object|null} The parsed message or null if invalid
+ * @property {string} [event] - The event type if specified
+ * @property {string|Object} data - The message data (parsed as JSON if possible)
+ * @property {string} [id] - The message ID if specified
+ * @property {number} [retry] - The retry interval if specified
+ */
+export function parseSSE(message) {
+  // console.log('parsing SSE', message);
+  const lines = message.split('\n')
+  const result = {
+    event: 'message', // Default event type
+    data: '',
+    id: null,
+    retry: null
+  }
+
+  for (const line of lines) {
+    if (line.startsWith('data:')) {
+      const data = line.slice(5).trim()
+      // Try to parse as JSON
+      try { result.data = JSON.parse(data) } 
+      // If not JSON, use as string
+      catch { result.data = data }
+      continue
+    } 
+    
+    if (line.startsWith('event:')) {
+      result.event = line.slice(6).trim()
+      continue
+    } 
+    
+    if (line.startsWith('id:')) {
+      result.id = line.slice(3).trim()
+      continue
+    } 
+    
+    if (line.startsWith('retry:')) {
+      result.retry = parseInt(line.slice(6).trim(), 10)
+      continue
+    }
+  }
+
+
+  const ret = omitEmpty(result)
+  // Only return if we have data
+  return ret.data ? ret : null
+}

package/node/dirname.js

@@ -1,5 +1,5 @@
+import path from 'node:path'
 import { fileURLToPath } from 'node:url'
-import path from 'path'
 
 /**
  * Returns __dirname

package/node/index.js

@@ -4,3 +4,4 @@ export * from './file-cache.js'
 export * from './hash.js'
 export * from './pkce.js'
 export * from './random-string.js'
+export * from './sanitize.js'

package/node/sanitize.js

@@ -0,0 +1,13 @@
+import sanitizeHtml from 'sanitize-html'
+import { sanitize as sanitizeLib } from '../lib/form/sanitize.js'
+
+/**
+ * Sanitizes values using sanitize-html
+ * @param {*} value - Value to sanitize (string, array, or object)
+ * @param {Object} [options={}] - sanitize-html options
+ * @returns {*} Sanitized value
+ * @throws {Error} If input is a string but sanitize-html fails
+ */
+export function sanitize(value, options = {}) {
+  return sanitizeLib(value, { sanitizer: sanitizeHtml })
+}

package/node/sanitize.spec.js

@@ -0,0 +1,142 @@
+import { describe, expect, it } from 'vitest'
+import { sanitize } from './sanitize.js'
+
+describe('node sanitize', () => {
+  describe('sanitize', () => {
+    it('removes script tags', () => {
+      const input = '<script>alert("xss")</script>Hello'
+      expect(sanitize(input)).toBe('Hello')
+    })
+
+    it('allows safe HTML tags', () => {
+      const input = '<p>Hello <b>World</b></p>'
+      expect(sanitize(input, { allowedTags: ['b'] })).toBe('Hello <b>World</b>')
+    })
+
+    it('sanitizes unsafe attributes', () => {
+      const input = '<a href="javascript:alert(1)">Click me</a>'
+      expect(
+        sanitize(input, {
+          allowedTags: ['a'],
+          allowedAttributes: { a: ['href'] },
+        }),
+      ).toBe('<a>Click me</a>')
+    })
+
+    it('allows safe attributes', () => {
+      const input = '<a href="https://example.com">Safe link</a>'
+      expect(
+        sanitize(input, {
+          allowedTags: ['a'],
+          allowedAttributes: { a: ['href'] },
+        }),
+      ).toBe('<a href="https://example.com">Safe link</a>')
+    })
+
+    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, {
+          allowedTags: ['b', 'i', 'em', 'strong', 'a'],
+          allowedAttributes: { a: ['href'] },
+        }),
+      ).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, {
+          allowedTags: ['b', 'i', 'em', 'strong', 'a'],
+          allowedAttributes: { a: ['href'] },
+        }),
+      ).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, {
+          allowedTags: ['b', 'i', 'em', 'strong', 'a'],
+          allowedAttributes: { a: ['href'] },
+        }),
+      ).toEqual(expected)
+    })
+
+    it('allows custom sanitizer options', () => {
+      const input = {
+        content: '<p>Hello <span>World</span> <script>alert(1)</script></p>',
+      }
+
+      // Test with custom allowed tags
+      const withSpan = sanitize(input, {
+        allowedTags: ['b', 'i', 'em', 'strong', 'a', 'span'],
+        allowedAttributes: { a: ['href'] },
+      })
+      expect(withSpan.content).toBe('Hello <span>World</span> ')
+
+      // Test with no allowed tags
+      const noTags = sanitize(input, {
+        allowedTags: [],
+        allowedAttributes: { a: ['href'] },
+      })
+      expect(noTags.content).toBe('Hello World ')
+    })
+  })
+})

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@splendidlabz/utils",
-  "version": "1.5.0-alpha.4",
+  "version": "1.5.0-beta.6",
   "description": "",
   "type": "module",
   "sideEffects": false,
@@ -19,12 +19,14 @@
   },
   "author": "Zell Liew <zellwk@gmail.com>",
   "dependencies": {
+    "deep-eql": "^5.0.2",
     "dompurify": "^3.2.4",
     "glob-promise": "^6.0.7",
     "marked": "^15.0.7",
     "marked-gfm-heading-id": "^4.1.1",
     "marked-mangle": "^1.1.10",
     "pluralize": "^8.0.0",
+    "sanitize-html": "^2.17.0",
     "statuses": "^2.0.1"
   },
   "devDependencies": {