@splendidlabz/utils 1.3.0

package/lib/date/months.js

@@ -0,0 +1,74 @@
+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/lib/form/form-data.js

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

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

package/lib/form/sanitize.js

@@ -0,0 +1,47 @@
+import DOMPurify from 'dompurify'
+
+/**
+ * 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.
+ */
+export function sanitize(html, options = {}) {
+  return DOMPurify.sanitize(html, options)
+}
+
+/**
+ * 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.
+ */
+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)]
+  })
+}
+
+/**
+ * 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.
+ */
+export function sanitizeObject(obj, options = {}) {
+  return Object.fromEntries(sanitizeEntries(Object.entries(obj), options))
+}

package/lib/functions/debounce.js

@@ -0,0 +1,18 @@
+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/lib/functions/env.js

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

package/lib/functions/functional.js

@@ -0,0 +1,31 @@
+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))
+      }
+    }
+  }
+}
+
+export function compose(...fns) {
+  return function (value) {
+    return fns.reduceRight((acc, fn) => fn(acc), value)
+  }
+}
+
+export function pipe(...fns) {
+  return function (value) {
+    return fns.reduce((acc, fn) => fn(acc), value)
+  }
+}
+
+export function times(fn, n) {
+  const result = []
+  for (let i = 0; i < n; i++) {
+    result.push(fn(i))
+  }
+  return result
+}

package/lib/functions/index.js

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

package/lib/functions/throttle.js

@@ -0,0 +1,11 @@
+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/lib/functions/timeout.js

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

@@ -0,0 +1,12 @@
+export * from './arrays/index.js'
+export * from './auth/index.js'
+export * from './checks.js'
+export * from './date/index.js'
+export * from './form/index.js'
+export * from './functions/index.js'
+export * from './numbers/index.js'
+export * from './objects/index.js'
+export * from './promises/index.js'
+export * from './strings/index.js'
+export * from './style/index.js'
+export * from './symbols/index.js'

package/lib/index.test.js

@@ -0,0 +1,9 @@
+// Possible to test???
+import * as test from './index.js'
+
+import { expect, it } from 'vitest'
+
+it('Import Test', () => {
+  console.log(test)
+  console.log('hello')
+})

package/lib/numbers/index.js

@@ -0,0 +1,10 @@
+export function splitUnit(string) {
+  // If there are no units, return the number straight.
+  if (typeof string === 'number') return [string, null]
+
+  const regex = /(-?\d*\.?\d+)([a-z]+)/i
+  const match = string.match(regex)
+
+  if (match) return [parseFloat(match[1]), match[2]]
+  return [parseFloat(string), null] // sometimes unitless numbers make it here if was typed into a string. This catches and returns it.
+}

package/lib/objects/camelcase-keys.js

@@ -0,0 +1,17 @@
+import { objectForEach } from './loop.js'
+import { toCamel } from '../strings/convert-case/convert-case.js'
+
+export function camelCaseKeys(obj) {
+  if (typeof obj !== 'object' || obj === null) {
+    return obj
+  }
+
+  const result = {}
+
+  objectForEach(obj, ({ key, value }) => {
+    const camelCaseKey = toCamel(key)
+    result[camelCaseKey] = camelCaseKeys(value)
+  })
+
+  return result
+}

package/lib/objects/camelcase-keys.test.js

@@ -0,0 +1,72 @@
+import { expect, it } from 'vitest'
+
+import { camelCaseKeys } from './camelcase-keys.js'
+
+it('Camelcase Basic', ctx => {
+  const object = {
+    lowercase: 1,
+    'Title Case': 2,
+    'kebab-case': 3,
+    PascalCase: 4,
+  }
+
+  const expected = {
+    lowercase: 1,
+    titleCase: 2,
+    kebabCase: 3,
+    pascalCase: 4,
+  }
+
+  const result = camelCaseKeys(object)
+  expect(result).toEqual(expected)
+})
+
+it('Camelcase Nested', ctx => {
+  const object = {
+    one: {
+      lowercase: 1,
+      'Title Case': 2,
+      'kebab-case': 3,
+      PascalCase: 4,
+    },
+  }
+
+  const expected = {
+    one: {
+      lowercase: 1,
+      titleCase: 2,
+      kebabCase: 3,
+      pascalCase: 4,
+    },
+  }
+
+  const result = camelCaseKeys(object)
+  expect(result).toEqual(expected)
+})
+
+it('Camelcase Deeply Nested', ctx => {
+  const object = {
+    one: {
+      two: {
+        lowercase: 1,
+        'Title Case': 2,
+        'kebab-case': 3,
+        PascalCase: 4,
+      },
+    },
+  }
+
+  const expected = {
+    one: {
+      two: {
+        lowercase: 1,
+        titleCase: 2,
+        kebabCase: 3,
+        pascalCase: 4,
+      },
+    },
+  }
+
+  const result = camelCaseKeys(object)
+  expect(result).toEqual(expected)
+})

package/lib/objects/empty.js

@@ -0,0 +1,10 @@
+export function isEmpty(obj) {
+  if (typeof obj === 'undefined') return true
+  if (obj === null) return true
+  if (Array.isArray(obj)) return obj.length === 0
+  return Object.keys(obj).length === 0
+}
+
+export function notEmpty(obj) {
+  return !isEmpty(obj)
+}

package/lib/objects/extend.js

@@ -0,0 +1,16 @@
+import { objectForEach, objectMap } from './loop.js'
+
+import { curry } from '../functions/functional.js'
+import { mix } from './mix/mix.js'
+
+// Need to manually curry these functions.
+
+export function extendObject(object) {
+  const orig = object
+  const extended = mix({}, object)
+
+  extended.forEach = curry(objectForEach)(orig)
+  extended.map = curry(objectMap)(orig)
+
+  return { orig, extended }
+}

package/lib/objects/extend.test.js

@@ -0,0 +1,35 @@
+import { beforeEach, expect, it } from 'vitest'
+
+import { extendObject } from '.'
+
+beforeEach(ctx => {
+  ctx.object = {
+    one: 1,
+    two: 2,
+  }
+})
+
+it('Object Extension', ctx => {
+  const { object } = ctx
+  const { extended, orig } = extendObject(object)
+
+  // Orig should be untouched
+  // Object should also be untouched
+  expect(object).toEqual(orig)
+  expect(object.forEach).toBeUndefined()
+  expect(object.map).toBeUndefined()
+
+  // Extended should be extended
+  expect(extended.one).toBe(1)
+  expect(extended.two).toBe(2)
+  expect(extended.forEach).toBeDefined()
+  expect(extended.map).toBeDefined()
+})
+
+it('Curried methods', ctx => {
+  const { extended } = extendObject(ctx.object)
+
+  // Extended methods should not be part of the object when looping
+  const test = extended.map(({ key, value }) => value)
+  expect(test).toEqual([1, 2])
+})

package/lib/objects/flatten.js

@@ -0,0 +1,19 @@
+import { isObject } from '../checks.js'
+
+export function flattenObject(obj, { separator, prefix = '' }) {
+  return Object.entries(obj).reduce((acc, [key, value]) => {
+    const newKey = prefix ? `${prefix}${separator}${key}` : key
+
+    const isAnObject = isObject(value)
+    const hasNestedObject = isAnObject && Object.values(value).some(isObject)
+
+    if (hasNestedObject) {
+      // If the value is an object, recursively flatten it.
+      Object.assign(acc, flattenObject(value, { separator, prefix: newKey }))
+    } else {
+      // Directly assign terminal values to the new key in the accumulator.
+      acc[newKey] = value
+    }
+    return acc
+  }, {})
+}

package/lib/objects/index.js

@@ -0,0 +1,12 @@
+export * from './camelcase-keys.js'
+export * from './empty.js'
+export * from './extend.js'
+export * from './flatten.js'
+export * from './json.js'
+export * from './loop.js'
+export * from './mix/mix.js'
+export * from './nested-property.js'
+export * from './normalize-object.js'
+export * from './omit-empty.js'
+export * from './size.js'
+export * from './split.js'

package/lib/objects/json.js

@@ -0,0 +1,7 @@
+export function parseJSON(value, defaultValue = {}) {
+  try {
+    return JSON.parse(value)
+  } catch (e) {
+    return defaultValue
+  }
+}

package/lib/objects/loop.js

@@ -0,0 +1,11 @@
+export function objectForEach(object, callback) {
+  Object.entries(object).forEach(([key, value]) => {
+    callback({ key, value })
+  })
+}
+
+export function objectMap(object, callback) {
+  return Object.entries(object).map(([key, value]) => {
+    return callback({ key, value })
+  })
+}

package/lib/objects/loop.test.js

@@ -0,0 +1,31 @@
+import { beforeEach, expect, it } from 'vitest'
+import { objectForEach, objectMap } from './loop.js'
+
+beforeEach(ctx => {
+  ctx.obj = {
+    one: 1,
+    two: 2,
+  }
+})
+
+it('Object For Each', ctx => {
+  const { obj } = ctx
+  const newObject = {}
+  function callback({ key, value }) {
+    newObject[key] = value
+  }
+
+  objectForEach(obj, callback)
+  expect(newObject).toEqual(obj)
+})
+
+it('Object Map', ctx => {
+  const { obj } = ctx
+
+  function callback({ key, value }) {
+    return value
+  }
+
+  const res = objectMap(obj, callback)
+  expect(res).toEqual([1, 2])
+})

package/lib/objects/mix/mix.js

@@ -0,0 +1,100 @@
+export function mix(...sources) {
+  const result = {}
+  for (const source of sources) {
+    merge(result, source)
+  }
+  return result
+}
+
+function merge(output, input) {
+  const props = Object.keys(input)
+
+  for (const prop of props) {
+    // Prevents Prototype Pollution
+    if (prop === '__proto__') continue
+
+    const descriptor = Object.getOwnPropertyDescriptor(input, prop)
+    const value = descriptor.value
+    if (value) descriptor.value = cloneDescriptorValue(value)
+
+    // If don't have prop => Define property
+    if (!output[prop]) {
+      Object.defineProperty(output, prop, descriptor)
+      continue
+    }
+
+    // If have prop, but type is not object => Overwrite by redefining property
+    if (typeof output[prop] !== 'object') {
+      Object.defineProperty(output, prop, descriptor)
+      continue
+    }
+
+    // If have prop, but type is Object => Concat the arrays together.
+    if (objectType(descriptor.value) === '[object Array]') {
+      output[prop] = output[prop].concat(descriptor.value)
+      continue
+    }
+
+    // If have prop, but type is Object => Merge.
+    merge(output[prop], descriptor.value)
+
+    // Not sure if I have to deal with overwriting maps / dates. When it comes, I guess!
+  }
+}
+
+// Creates a deep clone for each value
+function cloneDescriptorValue(value) {
+  // Arrays
+  if (objectType(value) === '[object Array]') {
+    const array = []
+    for (let v of value) {
+      v = cloneDescriptorValue(v)
+      array.push(v)
+    }
+    return array
+  }
+
+  // Objects
+  if (objectType(value) === '[object Object]') {
+    const obj = {}
+    const props = Object.keys(value)
+    for (const prop of props) {
+      const descriptor = Object.getOwnPropertyDescriptor(value, prop)
+      if (descriptor.value)
+        descriptor.value = cloneDescriptorValue(descriptor.value)
+      Object.defineProperty(obj, prop, descriptor)
+    }
+    return obj
+  }
+
+  // Other Types of Objects
+  if (objectType(value) === '[object Date]') {
+    return new Date(value.getTime())
+  }
+
+  if (objectType(value) === '[object Map]') {
+    const map = new Map()
+    for (const entry of value) {
+      map.set(entry[0], cloneDescriptorValue(entry[1]))
+    }
+    return map
+  }
+
+  if (objectType(value) === '[object Set]') {
+    const set = new Set()
+    for (const entry of value.entries()) {
+      set.add(cloneDescriptorValue(entry[0]))
+    }
+    return set
+  }
+
+  // Types we don't need to clone or cannot clone.
+  // Examples:
+  // - Primitives don't need to clone
+  // - Functions cannot clone
+  return value
+}
+
+function objectType(value) {
+  return Object.prototype.toString.call(value)
+}