@splendidlabz/utils 1.11.3 → 1.11.5

package/src/lib/objects/normalize-object.js

@@ -1,10 +0,0 @@
-import { pipe } from '../functions/functional.js'
-import { camelCaseKeys } from './camelcase-keys.js'
-import { omitEmpty } from './omit-empty.js'
-
-// Deprecated. Should remove.
-// Not using anymore.
-// Because snake_case is quite common.
-export function normalizeObject(object) {
-  return pipe(omitEmpty, camelCaseKeys)(object)
-}

package/src/lib/objects/omit-empty.js

@@ -1,23 +0,0 @@
-// Written by  AI and tested.
-export function omitEmpty(obj, shallow = false) {
-  if (typeof obj !== 'object' || obj === null) return obj
-  if (obj instanceof Date) return obj
-
-  const result = Array.isArray(obj) ? [] : {}
-
-  for (const [key, value] of Object.entries(obj)) {
-    if (
-      value === null ||
-      value === undefined ||
-      value === '' ||
-      (typeof value === 'object' &&
-        !(value instanceof Date) &&
-        Object.keys(value).length === 0)
-    ) {
-      continue
-    }
-    result[key] = shallow ? value : omitEmpty(value)
-  }
-
-  return result
-}

package/src/lib/objects/omit-empty.test.js

@@ -1,85 +0,0 @@
-import { expect, it } from 'vitest'
-
-import { omitEmpty } from './omit-empty'
-
-it('Omit Empty Basic', ctx => {
-  const date = new Date()
-  const object = {
-    // Should not be omitted
-    a: { one: 1 },
-    b: [1],
-    c: 1,
-    d: 0,
-    e: 'string',
-    k: date,
-    l: false,
-
-    // Should be omitted
-    f: {},
-    g: [],
-    h: '',
-    i: null,
-    j: undefined,
-  }
-
-  const expected = {
-    a: { one: 1 },
-    b: [1],
-    c: 1,
-    d: 0,
-    e: 'string',
-    k: date,
-    l: false,
-  }
-
-  const result = omitEmpty(object)
-  expect(result).toEqual(expected)
-})
-
-it('Omit Empty Nested', ctx => {
-  const object = {
-    a: {
-      one: {},
-      two: [],
-      three: 1,
-      four: 'string',
-    },
-  }
-
-  const expected = {
-    a: {
-      three: 1,
-      four: 'string',
-    },
-  }
-
-  const result = omitEmpty(object)
-  expect(result).toEqual(expected)
-})
-
-it('Omit Empty Recursive', ctx => {
-  const object = {
-    a: {
-      one: {},
-      two: [],
-      three: {
-        alpha: {},
-        beta: [],
-        tetha: 1,
-        gamma: 'string',
-      },
-    },
-  }
-
-  const expected = {
-    a: {
-      three: {
-        tetha: 1,
-        gamma: 'string',
-      },
-    },
-  }
-
-  const result = omitEmpty(object)
-  expect(result).toEqual(expected)
-})

package/src/lib/objects/size.js

@@ -1,41 +0,0 @@
-// https://gist.github.com/rajinwonderland/36887887b8a8f12063f1d672e318e12e
-export function sizeOf(obj) {
-  let bytes = 0
-
-  function size(obj) {
-    if (obj !== null && obj !== undefined) {
-      switch (typeof obj) {
-        case 'number':
-          bytes += 8
-          break
-        case 'string':
-          bytes += obj.length * 2
-          break
-        case 'boolean':
-          bytes += 4
-          break
-        case 'object':
-          // eslint-disable-next-line no-case-declarations
-          const objClass = Object.prototype.toString.call(obj).slice(8, -1)
-          if (objClass === 'Object' || objClass === 'Array') {
-            for (const key in obj) {
-              // eslint-disable-next-line no-prototype-builtins
-              if (!obj.hasOwnProperty(key)) continue
-              size(obj[key])
-            }
-          } else bytes += obj.toString().length * 2
-          break
-      }
-    }
-    return bytes
-  }
-
-  function formatByteSize(bytes) {
-    if (bytes < 1024) return bytes + ' bytes'
-    else if (bytes < 1048576) return (bytes / 1024).toFixed(3) + ' KiB'
-    else if (bytes < 1073741824) return (bytes / 1048576).toFixed(3) + ' MiB'
-    else return (bytes / 1073741824).toFixed(3) + ' GiB'
-  }
-
-  return formatByteSize(size(obj))
-}

package/src/lib/objects/split.js

@@ -1,19 +0,0 @@
-/**
- * Split on object up based on the keys provided.
- * @param {Object} obj
- * @param {Array} keys
- * @returns
- */
-export function splitObject(obj, keys) {
-  const picked = {}
-  const omitted = { ...obj }
-
-  keys.forEach(key => {
-    if (key in obj) {
-      picked[key] = obj[key]
-      delete omitted[key]
-    }
-  })
-
-  return { picked, omitted, p: picked, o: omitted }
-}

package/src/lib/promises/index.js

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

package/src/lib/promises/reject.js

@@ -1,17 +0,0 @@
-import statuses from 'statuses'
-import { omitEmpty } from '../objects/omit-empty.js'
-
-// Rejects a promise with HTTP Status Code
-export function reject(props, { includeStack = true } = {}) {
-  const { status, statusText, body, message } = props
-  const e = new Error()
-  const err = {
-    status,
-    statusText: statusText || (status && statuses(status)),
-    body,
-    message,
-    stack: includeStack && e.stack,
-  }
-
-  return Promise.reject(omitEmpty(err))
-}

package/src/lib/sse.js

@@ -1,61 +0,0 @@
-// Server Sent Events (SSE) 
-import { parseJSON } from './objects/json.js'
-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) {
-  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()
-      result.data = parseJSON(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)
-  return ret.data ? ret : null
-}
-

package/src/lib/strings/convert-case/convert-case.js

@@ -1,86 +0,0 @@
-// ========================
-// Case Conversion Utilities
-// Note: All case conversion functions require `toKebab` to work.
-// ------------------------
-export function toKebab(string) {
-  if (!string) return ''
-  return string
-    .split('')
-    .map((letter, index) => {
-      const previousLetter = string[index - 1] || ''
-      const currentLetter = letter
-
-      if (isDigit(currentLetter) && !isDigit(previousLetter)) {
-        return `-${currentLetter}`
-      }
-
-      if (!isCaps(currentLetter)) return currentLetter
-
-      if (previousLetter === '') {
-        return `${currentLetter.toLowerCase()}`
-      }
-
-      if (isCaps(previousLetter)) {
-        return `${currentLetter.toLowerCase()}`
-      }
-
-      return `-${currentLetter.toLowerCase()}`
-    })
-    .join('')
-    .trim()
-    .replace(/[-_\s]+/g, '-')
-}
-
-export function toCamel(string) {
-  return toKebab(string)
-    .split('-')
-    .map((word, index) => {
-      if (index === 0) return word
-      return word.slice(0, 1).toUpperCase() + word.slice(1).toLowerCase()
-    })
-    .join('')
-}
-
-export function toPascal(string) {
-  const camel = toCamel(string)
-  return camel.slice(0, 1).toUpperCase() + camel.slice(1)
-}
-
-export function toTitle(string) {
-  return toKebab(string)
-    .split('-')
-    .map(word => {
-      return word.slice(0, 1).toUpperCase() + word.slice(1)
-    })
-    .join(' ')
-}
-
-export function toSlug(string) {
-  return toKebab(string)
-}
-
-export function toSentence(string) {
-  const interim = toKebab(string).replace(/-/g, ' ')
-  return interim.slice(0, 1).toUpperCase() + interim.slice(1)
-}
-
-export function toUpper(string) {
-  const interim = toKebab(string).replace(/-/g, ' ')
-  return interim.toUpperCase()
-}
-
-export function toLower(string) {
-  const interim = toKebab(string).replace(/-/g, ' ')
-  return interim.toLowerCase()
-}
-
-// Checks whether character is Uppercase.
-// Crude version. Checks only A-Z.
-function isCaps(char) {
-  return /\p{Lu}/u.test(char)
-}
-
-// Checks whether character is digit.
-function isDigit(char) {
-  return /[0-9]/.test(char)
-}

package/src/lib/strings/convert-case/convert-case.md

@@ -1,44 +0,0 @@
-# Case Conversion Utilities
-
-This file contains utilities to convert any string into the following cases:
-
-1. `kebab-case`
-2. `camelCase`
-3. `Title Case`
-4. `Sentence case`
-
-[See my process for creating these case-conversion utilties](https://zellwk.com/blog/case-conversion)
-
-## Examples
-
-```javascript
-toKebab('caseWithSomeWords') // case-with-some-words
-toKebab('CaseWithSomeWords') // case-with-some-words
-toKebab('case_with_some_words') // case-with-some-words
-toKebab('Case with some words') // case-with-some-words
-toKebab('Case With Some Words') // case-with-some-words
-toKebab('Case_with SomeWords') // case-with-some-words
-```
-
-## Installation
-
-Manual installation:
-
-- Copy and paste the entire file into your javascript file. 😉
-- If you use ES5 Modules, you can import them into your file
-
-```js
-import { toKebab } from "./convert-case.js"
-toKebab('someString')
-```
-
-NPM:
-
-- Run `npm install @zellwk/javascript`
-- Import `convert-case.js`
-
-```js
-import { toKebab } from "@zellwk/javascript/convert-case"
-toKebab('someString')
-```
-

package/src/lib/strings/convert-case/convert-case.test.js

@@ -1,50 +0,0 @@
-/* eslint-env jest */
-import { describe, expect, it } from 'vitest'
-import { toCamel, toKebab, toSentence, toTitle } from './convert-case'
-
-const cases = {
-  kebab: 'case-with-long-name100',
-  snake: 'case_with_long_name100',
-  camel: 'caseWithLongName100',
-  pascal: 'CaseWithLongName100',
-  sentence: 'Case with long name100',
-  title: 'Case With Long Name100',
-  constant: 'CASE_WITH_LONG_NAME100',
-  mixCases: 'case_WITH-Long name100',
-}
-
-describe('To Kebab', _ => {
-  Object.entries(cases).forEach(c => {
-    it(`From ${c[0]}`, () => {
-      const result = toKebab(c[1])
-      expect(result, c[0]).toBe('case-with-long-name-100')
-    })
-  })
-})
-
-describe('To Camel', _ => {
-  Object.entries(cases).forEach(c => {
-    it(`From ${c[0]}`, () => {
-      const result = toCamel(c[1])
-      expect(result, c[0]).toBe('caseWithLongName100')
-    })
-  })
-})
-
-describe('To Sentence', _ => {
-  Object.entries(cases).forEach(c => {
-    it(`From ${c[0]}`, () => {
-      const result = toSentence(c[1])
-      expect(result, c[0]).toBe('Case with long name 100')
-    })
-  })
-})
-
-describe('To Title', _ => {
-  Object.entries(cases).forEach(c => {
-    it(`From ${c[0]}`, () => {
-      const result = toTitle(c[1])
-      expect(result, c[0]).toBe('Case With Long Name 100')
-    })
-  })
-})

package/src/lib/strings/index.js

@@ -1,5 +0,0 @@
-export * from './convert-case/convert-case.js'
-export * from './markdown.js'
-export * from './name.js'
-export * from './pluralize.js'
-export * from './query-string.js'

package/src/lib/strings/markdown.js

@@ -1,71 +0,0 @@
-import markdownit from 'markdown-it'
-import anchor from 'markdown-it-anchor'
-
-const md = markdownit({
-  html: true,
-  linkify: true,
-  typographer: true,
-})
-
-md.use(anchor, {
-  permalink: false,
-  slugify: s =>
-    s
-      .toLowerCase()
-      .replace(/\s+/g, '-')
-      .replace(/[^\w-]/g, ''),
-})
-
-/**
- * Converts markdown content to HTML with whitespace handling
- * @param {string} content - Markdown content to convert
- * @param {Object} [options={}] - Conversion options
- * @param {boolean} [options.inline=false] - Whether content should be treated as inline markdown
- * @returns {string} Converted HTML string
- */
-export function markdown(content, options = {}) {
-  const defaultOptions = { inline: false }
-  const opts = { ...defaultOptions, ...options }
-
-  const { content: treated } = treatMarkdownWhitespace(content, opts)
-
-  if (opts.inline) return md.renderInline(treated)
-  return md.render(treated)
-}
-
-/**
- * Handles whitespace in markdown content to ensure proper rendering
- * @param {string} content - Markdown content to process
- * @param {Object} [options={}] - Processing options
- * @param {boolean} [options.inline=false] - Whether content is inline markdown
- * @returns {{ content: string, inline: boolean }} Processed content and inline status
- */
-export function treatMarkdownWhitespace(content, { inline } = {}) {
-  if (!content) return { content: '', inline }
-  const lines = content.split('\n')
-
-  // Check for inline content
-  if (lines[0] !== '' && inline) return { content, inline: true }
-
-  // If it's not inline content, we need to strip indentation
-  // For this, we need to check for the first new line with leading spaces
-  const firstLineWithLeadingSpacesIndex = lines.findIndex(line =>
-    line.match(/^\s+/),
-  )
-  const firstLineWithLeadingSpaces = lines[firstLineWithLeadingSpacesIndex]
-  const indentation =
-    firstLineWithLeadingSpaces?.match(/^\s+/)?.[0]?.length ?? 0
-
-  // Once the indentation is found, we strip the indentation from each line. This treats the Markdown whitespace and prevents it from being rendered as code blocks.
-  const retContent = lines
-    .map((line, index) => {
-      if (index < firstLineWithLeadingSpacesIndex) return line + '\n'
-      return line.slice(indentation) + '\n'
-    })
-    .join('')
-
-  return {
-    content: retContent,
-    inline,
-  }
-}

package/src/lib/strings/markdown.spec.js

@@ -1,73 +0,0 @@
-import { describe, expect, test } from 'vitest'
-import { markdown, treatMarkdownWhitespace } from './markdown.js'
-
-describe('markdown', () => {
-  describe('block (default)', () => {
-    test('wraps output in <p>', () => {
-      const result = markdown('hello')
-      expect(result).toBe('<p>hello</p>\n')
-    })
-
-    test('renders bold', () => {
-      const result = markdown('**bold**')
-      expect(result).toBe('<p><strong>bold</strong></p>\n')
-    })
-
-    test('renders headings', () => {
-      const result = markdown('# Hello')
-      expect(result).toContain('<h1')
-      expect(result).toContain('Hello</h1>')
-    })
-  })
-
-  describe('inline', () => {
-    test('never produces <p> tags', () => {
-      const result = markdown('hello', { inline: true })
-      expect(result).not.toContain('<p>')
-      expect(result).not.toContain('</p>')
-    })
-
-    test('plain text renders as-is', () => {
-      const result = markdown('hello', { inline: true })
-      expect(result).toBe('hello')
-    })
-
-    test('renders bold without <p>', () => {
-      const result = markdown('**bold**', { inline: true })
-      expect(result).toBe('<strong>bold</strong>')
-    })
-
-    test('renders em without <p>', () => {
-      const result = markdown('_em_', { inline: true })
-      expect(result).toBe('<em>em</em>')
-    })
-
-    test('renders inline code without <p>', () => {
-      const result = markdown('`code`', { inline: true })
-      expect(result).toBe('<code>code</code>')
-    })
-  })
-})
-
-describe('treatMarkdownWhitespace', () => {
-  test('returns empty string for falsy content', () => {
-    const a = treatMarkdownWhitespace('')
-    const b = treatMarkdownWhitespace(null)
-    const c = treatMarkdownWhitespace(undefined)
-    expect(a.content).toBe('')
-    expect(b.content).toBe('')
-    expect(c.content).toBe('')
-  })
-
-  test('strips leading indentation', () => {
-    const { content } = treatMarkdownWhitespace('\n  hello\n  world')
-    expect(content).not.toContain('  hello')
-    expect(content).toContain('hello')
-    expect(content).toContain('world')
-  })
-
-  test('returns inline content as-is when first line is not empty', () => {
-    const { content } = treatMarkdownWhitespace('hello world', { inline: true })
-    expect(content).toBe('hello world')
-  })
-})

package/src/lib/strings/name.js

@@ -1,24 +0,0 @@
-export function parseFullName(name) {
-  const parts = name.trim().split(/\s+/)
-
-  if (parts.length === 1) {
-    return { firstName: parts[0], middleName: '', lastName: '' }
-  }
-
-  if (parts.length === 2) {
-    return { firstName: parts[0], middleName: '', lastName: parts[1] }
-  }
-
-  if (parts.length === 3) {
-    const firstName = parts.slice(0, 2).join(' ')
-    const lastName = parts[2]
-    return { firstName, middleName: '', lastName }
-  }
-
-  // 4+ words: first 2 words = firstName, last word = lastName, middle = middleName
-  const firstName = parts.slice(0, 2).join(' ')
-  const lastName = parts[parts.length - 1]
-  const middleName = parts.slice(2, -1).join(' ')
-
-  return { firstName, middleName, lastName }
-}

package/src/lib/strings/name.test.js

@@ -1,67 +0,0 @@
-import { describe, expect, test } from 'vitest'
-import { parseFullName } from './name.js'
-
-describe('parseFullName', () => {
-  test('handles single name', () => {
-    const result = parseFullName('John')
-    expect(result).toEqual({
-      firstName: 'John',
-      middleName: '',
-      lastName: '',
-    })
-  })
-
-  test('handles two names', () => {
-    const result = parseFullName('John Doe')
-    expect(result).toEqual({
-      firstName: 'John',
-      middleName: '',
-      lastName: 'Doe',
-    })
-  })
-
-  test('handles three names (Chinese pattern)', () => {
-    const result = parseFullName('Wee Keat Liew')
-    expect(result).toEqual({
-      firstName: 'Wee Keat',
-      middleName: '',
-      lastName: 'Liew',
-    })
-  })
-
-  test('handles four names with middle name', () => {
-    const result = parseFullName('Mary Jane Michael Doe')
-    expect(result).toEqual({
-      firstName: 'Mary Jane',
-      middleName: 'Michael',
-      lastName: 'Doe',
-    })
-  })
-
-  test('handles five names with multiple middle names', () => {
-    const result = parseFullName('Mary Jane Catherine Elizabeth Doe')
-    expect(result).toEqual({
-      firstName: 'Mary Jane',
-      middleName: 'Catherine Elizabeth',
-      lastName: 'Doe',
-    })
-  })
-
-  test('handles extra whitespace', () => {
-    const result = parseFullName('  John   Doe  ')
-    expect(result).toEqual({
-      firstName: 'John',
-      middleName: '',
-      lastName: 'Doe',
-    })
-  })
-
-  test('handles multiple spaces between words', () => {
-    const result = parseFullName('Wee    Keat   Liew')
-    expect(result).toEqual({
-      firstName: 'Wee Keat',
-      middleName: '',
-      lastName: 'Liew',
-    })
-  })
-})

package/src/lib/strings/pluralize.js

@@ -1,2 +0,0 @@
-import pluralizeLib from 'pluralize'
-export const pluralize = pluralizeLib