@splendidlabz/utils 1.5.1 → 1.7.0

package/src/lib/checks.js

@@ -0,0 +1,53 @@
+/**
+ * Checks if a value is a plain object (not an array or null)
+ * @param {unknown} x - The value to check
+ * @returns {boolean} True if the value is a plain object
+ * @example
+ * isObject({}) // true
+ * isObject([]) // false
+ * isObject(null) // false
+ */
+export function isObject(x) {
+  return typeof x === 'object' && !Array.isArray(x) && x !== null
+}
+
+/**
+ * Checks if a value is an array
+ * @param {unknown} x - The value to check
+ * @returns {boolean} True if the value is an array
+ * @example
+ * isArray([]) // true
+ * isArray({}) // false
+ */
+export function isArray(x) {
+  return Array.isArray(x)
+}
+
+/**
+ * Checks if a value is not a plain object
+ * @param {unknown} x - The value to check
+ * @returns {boolean} True if the value is not a plain object
+ * @example
+ * notObject([]) // true
+ * notObject(null) // true
+ * notObject({}) // false
+ */
+export function notObject(x) {
+  return !isObject(x)
+}
+
+export function getType(x) {
+  if (typeof x === 'string') return 'string'
+  if (typeof x === 'number') {
+    if (Number.isInteger(x)) return 'integer'
+    return 'float'
+  }
+  if (typeof x === 'boolean') return 'boolean'
+  if (typeof x === 'function') return 'function'
+  if (typeof x === 'undefined') return 'undefined'
+  if (typeof x === 'symbol') return 'symbol'
+  if (typeof x === 'bigint') return 'bigint'
+  if (Array.isArray(x)) return 'array'
+  if (typeof x === 'object') return 'object'
+  return 'unknown'
+}

package/{lib → src/lib}/date/time.js

@@ -27,11 +27,6 @@ export function ms(arg) {
   return value
 }
 
-export function seconds(arg) {
-  const value = ms(arg)
-  return value / 1000
-}
-
 export function getTimeInMs(value, unit = 'ms') {
   switch (unit) {
     case 'ms':
@@ -48,3 +43,39 @@ export function getTimeInMs(value, unit = 'ms') {
       return value * 1000 * 60 * 60 * 24 * 7
   }
 }
+
+export function toWeeks(ms) {
+  return ms / 1000 / 60 / 60 / 24 / 7
+}
+
+export function toDays(ms) {
+  return ms / 1000 / 60 / 60 / 24
+}
+
+export function toHours(ms) {
+  return ms / 1000 / 60 / 60
+}
+
+export function toMinutes(ms) {
+  return ms / 1000 / 60
+}
+
+export function toSeconds(ms) {
+  return ms / 1000
+}
+
+// Get the total number of weeks, days, hours, minutes, and seconds
+export function toReadableTime(ms) {
+  const weekMs = 1000 * 60 * 60 * 24 * 7
+  const dayMs = 1000 * 60 * 60 * 24
+  const hourMs = 1000 * 60 * 60
+  const minuteMs = 1000 * 60
+
+  const weeks = Math.floor(ms / weekMs)
+  const days = Math.floor((ms % weekMs) / dayMs)
+  const hours = Math.floor((ms % dayMs) / hourMs)
+  const minutes = Math.floor((ms % hourMs) / minuteMs)
+  const seconds = Math.floor((ms % minuteMs) / 1000)
+
+  return { weeks, days, hours, minutes, seconds }
+}

package/src/lib/hash.js

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

package/src/lib/hash.spec.js

@@ -0,0 +1,163 @@
+import { describe, expect, it } from 'vitest'
+import { isHashedValue } from './hash.js'
+
+describe('isHashedValue', () => {
+  describe('SHA256 hashes', () => {
+    it('returns true for valid SHA256 hash', () => {
+      const validSha256 =
+        'a665a45920422f9d417e4867efdc4fb8a04a1f3fff1fa07e998e86f7f7a27ae3'
+      expect(isHashedValue(validSha256, 'sha256')).toBe(true)
+      expect(isHashedValue(validSha256)).toBe(true) // default type
+    })
+
+    it('returns true for valid SHA256 hash with uppercase letters', () => {
+      const validSha256 =
+        'A665A45920422F9D417E4867EFDC4FB8A04A1F3FFF1FA07E998E86F7F7A27AE3'
+      expect(isHashedValue(validSha256, 'sha256')).toBe(true)
+    })
+
+    it('returns true for valid SHA256 hash with mixed case', () => {
+      const validSha256 =
+        'A665a45920422F9d417E4867efdc4FB8a04a1F3fff1FA07e998E86f7f7A27ae3'
+      expect(isHashedValue(validSha256, 'sha256')).toBe(true)
+    })
+
+    it('returns false for SHA256 hash with wrong length', () => {
+      const shortHash =
+        'a665a45920422f9d417e4867efdc4fb8a04a1f3fff1fa07e998e86f7f7a27ae'
+      const longHash =
+        'a665a45920422f9d417e4867efdc4fb8a04a1f3fff1fa07e998e86f7f7a27ae33'
+      expect(isHashedValue(shortHash, 'sha256')).toBe(false)
+      expect(isHashedValue(longHash, 'sha256')).toBe(false)
+    })
+
+    it('returns false for SHA256 hash with invalid characters', () => {
+      const invalidHash =
+        'g665a45920422f9d417e4867efdc4fb8a04a1f3fff1fa07e998e86f7f7a27ae3'
+      expect(isHashedValue(invalidHash, 'sha256')).toBe(false)
+    })
+  })
+
+  describe('SHA1 hashes', () => {
+    it('returns true for valid SHA1 hash', () => {
+      const validSha1 = '356a192b7913b04c54574d18c28d46e6395428ab'
+      expect(isHashedValue(validSha1, 'sha1')).toBe(true)
+    })
+
+    it('returns true for valid SHA1 hash with uppercase letters', () => {
+      const validSha1 = '356A192B7913B04C54574D18C28D46E6395428AB'
+      expect(isHashedValue(validSha1, 'sha1')).toBe(true)
+    })
+
+    it('returns false for SHA1 hash with wrong length', () => {
+      const shortHash = '356a192b7913b04c54574d18c28d46e6395428a'
+      const longHash = '356a192b7913b04c54574d18c28d46e6395428abb'
+      expect(isHashedValue(shortHash, 'sha1')).toBe(false)
+      expect(isHashedValue(longHash, 'sha1')).toBe(false)
+    })
+
+    it('returns false for SHA1 hash with invalid characters', () => {
+      const invalidHash = '356g192b7913b04c54574d18c28d46e6395428ab'
+      expect(isHashedValue(invalidHash, 'sha1')).toBe(false)
+    })
+  })
+
+  describe('MD5 hashes', () => {
+    it('returns true for valid MD5 hash', () => {
+      const validMd5 = '5d41402abc4b2a76b9719d911017c592'
+      expect(isHashedValue(validMd5, 'md5')).toBe(true)
+    })
+
+    it('returns true for valid MD5 hash with uppercase letters', () => {
+      const validMd5 = '5D41402ABC4B2A76B9719D911017C592'
+      expect(isHashedValue(validMd5, 'md5')).toBe(true)
+    })
+
+    it('returns false for MD5 hash with wrong length', () => {
+      const shortHash = '5d41402abc4b2a76b9719d911017c59'
+      const longHash = '5d41402abc4b2a76b9719d911017c5922'
+      expect(isHashedValue(shortHash, 'md5')).toBe(false)
+      expect(isHashedValue(longHash, 'md5')).toBe(false)
+    })
+
+    it('returns false for MD5 hash with invalid characters', () => {
+      const invalidHash = '5g41402abc4b2a76b9719d911017c592'
+      expect(isHashedValue(invalidHash, 'md5')).toBe(false)
+    })
+  })
+
+  describe('Type parameter handling', () => {
+    it('handles case insensitive type parameter', () => {
+      const validSha256 =
+        'a665a45920422f9d417e4867efdc4fb8a04a1f3fff1fa07e998e86f7f7a27ae3'
+      expect(isHashedValue(validSha256, 'SHA256')).toBe(true)
+      expect(isHashedValue(validSha256, 'Sha256')).toBe(true)
+      expect(isHashedValue(validSha256, 'sHa256')).toBe(true)
+    })
+
+    it('returns null for unsupported hash type', () => {
+      const validSha256 =
+        'a665a45920422f9d417e4867efdc4fb8a04a1f3fff1fa07e998e86f7f7a27ae3'
+      expect(isHashedValue(validSha256, 'sha512')).toBe(null)
+      expect(isHashedValue(validSha256, 'blake2b')).toBe(null)
+      expect(isHashedValue(validSha256, 'unknown')).toBe(null)
+    })
+  })
+
+  describe('Input validation', () => {
+    it('returns null for non-string inputs', () => {
+      expect(isHashedValue(null)).toBe(null)
+      expect(isHashedValue(undefined)).toBe(null)
+      expect(isHashedValue(123)).toBe(null)
+      expect(isHashedValue([])).toBe(null)
+      expect(isHashedValue({})).toBe(null)
+      expect(isHashedValue(true)).toBe(null)
+    })
+
+    it('handles empty string', () => {
+      expect(isHashedValue('')).toBe(false)
+      expect(isHashedValue('', 'sha1')).toBe(false)
+      expect(isHashedValue('', 'md5')).toBe(false)
+    })
+
+    it('trims whitespace from input', () => {
+      const validSha256 =
+        '  a665a45920422f9d417e4867efdc4fb8a04a1f3fff1fa07e998e86f7f7a27ae3  '
+      expect(isHashedValue(validSha256, 'sha256')).toBe(true)
+    })
+
+    it('returns false for strings with only whitespace', () => {
+      expect(isHashedValue('   ')).toBe(false)
+      expect(isHashedValue('\t\n')).toBe(false)
+    })
+  })
+
+  describe('Edge cases', () => {
+    it('returns false for strings that are all zeros but correct length', () => {
+      const zeroSha256 =
+        '0000000000000000000000000000000000000000000000000000000000000000'
+      const zeroSha1 = '0000000000000000000000000000000000000000'
+      const zeroMd5 = '00000000000000000000000000000000'
+
+      expect(isHashedValue(zeroSha256, 'sha256')).toBe(true)
+      expect(isHashedValue(zeroSha1, 'sha1')).toBe(true)
+      expect(isHashedValue(zeroMd5, 'md5')).toBe(true)
+    })
+
+    it('returns false for correct length but non-hex characters', () => {
+      const nonHexSha256 =
+        'g665a45920422f9d417e4867efdc4fb8a04a1f3fff1fa07e998e86f7f7a27ae3'
+      const nonHexSha1 = '356g192b7913b04c54574d18c28d46e6395428ab'
+      const nonHexMd5 = '5g41402abc4b2a76b9719d911017c592'
+
+      expect(isHashedValue(nonHexSha256, 'sha256')).toBe(false)
+      expect(isHashedValue(nonHexSha1, 'sha1')).toBe(false)
+      expect(isHashedValue(nonHexMd5, 'md5')).toBe(false)
+    })
+
+    it('handles special characters correctly', () => {
+      const specialChars = '!@#$%^&*()_+-=[]{}|;:,.<>?/~`'
+      expect(isHashedValue(specialChars, 'sha256')).toBe(false)
+    })
+  })
+})

package/{lib → src/lib}/index.js

@@ -4,6 +4,7 @@ export * from './checks.js'
 export * from './date/index.js'
 export * from './form/index.js'
 export * from './functions/index.js'
+export * from './hash.js'
 export * from './numbers/index.js'
 export * from './objects/index.js'
 export * from './promises/index.js'

package/{lib → src/lib}/objects/mix/mix.js

@@ -1,14 +1,24 @@
-export function mix(...sources) {
-  const result = {}
-  for (const source of sources) {
-    // Skip null or undefined sources
-    if (source == null) continue
-    merge(result, source)
+const DEFAULT_OPTIONS = { array: 'concat' }
+
+export const mix = createMix()
+
+export function createMix(userOptions = {}) {
+  const options = { ...DEFAULT_OPTIONS, ...userOptions }
+
+  function _mix(...sources) {
+    const result = {}
+    for (const source of sources) {
+      // Skip null or undefined sources
+      if (source == null) continue
+      merge(result, source, options)
+    }
+    return result
   }
-  return result
+
+  return _mix
 }
 
-function merge(output, input) {
+function merge(output, input, options) {
   const props = Object.keys(input)
 
   for (const prop of props) {
@@ -31,14 +41,23 @@ function merge(output, input) {
       continue
     }
 
-    // If have prop, but type is Object => Concat the arrays together.
+    // Incoming non-object (primitive/null) => always overwrite
+    if (descriptor.value == null || typeof descriptor.value !== 'object') {
+      Object.defineProperty(output, prop, descriptor)
+      continue
+    }
+
+    // If have prop, and incoming is Array => concat or replace
     if (objectType(descriptor.value) === '[object Array]') {
-      output[prop] = output[prop].concat(descriptor.value)
+      output[prop] =
+        options.array === 'replace'
+          ? descriptor.value.slice()
+          : output[prop].concat(descriptor.value)
       continue
     }
 
     // If have prop, but type is Object => Merge.
-    merge(output[prop], descriptor.value)
+    merge(output[prop], descriptor.value, options)
 
     // Not sure if I have to deal with overwriting maps / dates. When it comes, I guess!
   }

package/{lib → src/lib}/objects/mix/mix.test.js

@@ -1,6 +1,6 @@
 import { expect, it } from 'vitest'
 
-import { mix } from './mix.js'
+import { createMix, mix } from './mix.js'
 
 it('Merge objects', () => {
   const one = { one: 'one', overwrite: 'nope' }
@@ -338,3 +338,59 @@ it('should skip null and undefined sources', () => {
 
   expect(mix(null, obj1, undefined, obj2, null)).toEqual(expected)
 })
+
+it('should not skip null and false properties', () => {
+  const obj1 = { a: 1, b: 2, c: 3 }
+  const obj2 = { a: null, b: false, c: undefined }
+  const expected = { a: null, b: false, c: undefined }
+
+  expect(mix(obj1, obj2)).toEqual(expected)
+})
+
+it('Real Nested Example', () => {
+  const defaultOpts = {
+    transforms: {
+      extractFromFileName: { date: 'pubDate', slug: 'slug' },
+      setLatestDate: {
+        targetProperty: 'date',
+        sourceProperties: ['pubDate', 'updateDate'],
+      },
+      generateExcerpt: true,
+      stripFileNumbering: true,
+      stripMore: true,
+    },
+    sort: {
+      props: ['data.date', 'data.pubDate', 'data.title'],
+      reverse: true,
+    },
+    filter: 'published',
+  }
+
+  const newOptions = {
+    transforms: {
+      extractFromFileName: false,
+      generateExcerpt: false,
+      stripMore: false,
+      // stripFileNumbering: true,
+    },
+    sort: { props: ['filePath'], reverse: false },
+    filter: false,
+  }
+  const expected = {
+    transforms: {
+      setLatestDate: {
+        targetProperty: 'date',
+        sourceProperties: ['pubDate', 'updateDate'],
+      },
+      extractFromFileName: false,
+      generateExcerpt: false,
+      stripFileNumbering: true,
+      stripMore: false,
+    },
+    sort: { props: ['filePath'], reverse: false },
+    filter: false,
+  }
+
+  const mixReplace = createMix({ array: 'replace' })
+  expect(mixReplace(defaultOpts, newOptions)).toEqual(expected)
+})

package/{lib → src/lib}/objects/split.js

@@ -15,5 +15,5 @@ export function splitObject(obj, keys) {
     }
   })
 
-  return { picked, omitted }
+  return { picked, omitted, p: picked, o: omitted }
 }

package/{lib → src/lib}/strings/index.js

@@ -1,4 +1,5 @@
 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/name.js

@@ -0,0 +1,24 @@
+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

@@ -0,0 +1,67 @@
+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

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

package/{lib → src/lib}/style/index.js

@@ -1,6 +1,8 @@
 import { toKebab } from '../strings/convert-case/convert-case.js'
 
 export function toStyleString(style) {
+  if (!style) return null
+  if (typeof style === 'string') return style
   return Object.entries(style)
     .map(([k, v]) => {
       if (k.startsWith('--')) return `${k}:${v}`

package/src/node/random-string.js

@@ -0,0 +1,10 @@
+import crypto from 'node:crypto'
+
+export function randomString(length = 32) {
+  // Calculate bytes needed for desired character length
+  // Base64: 4 chars per 3 bytes, so we need ceil(length * 3 / 4) bytes
+  // Add extra bytes to ensure we have enough after encoding
+  const bytesNeeded = Math.ceil((length * 3) / 4) + 3
+
+  return crypto.randomBytes(bytesNeeded).toString('base64').slice(0, length)
+}

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

@@ -0,0 +1,15 @@
+import { describe, expect, it } from 'vitest'
+import { randomString } from './random-string.js'
+
+describe('randomString', () => {
+  it('should generate a random string', () => {
+    const str = randomString(32)
+    expect(str).toBeDefined()
+    expect(str.length).toBe(32)
+
+    const str2 = randomString(40)
+    expect(str2).toBeDefined()
+    expect(str2.length).toBe(40)
+    expect(str2).not.toBe(str)
+  })
+})

package/tsconfig.json

@@ -6,18 +6,18 @@
     "allowJs": true,
     "checkJs": true,
     "declaration": true,
-    "emitDeclarationOnly": true,
-    "outDir": "./dist",
+    "emitDeclarationOnly": false,
+    "outDir": "./dist/temp",
     "strict": false,
     "noImplicitAny": false,
     "skipLibCheck": true,
     "forceConsistentCasingInFileNames": true,
     "resolveJsonModule": true,
     "isolatedModules": true,
-    "noEmit": false,
+    "noEmit": true,
     "esModuleInterop": true,
     "allowSyntheticDefaultImports": true
   },
-  "include": ["lib/**/*", "dom/**/*", "node/**/*"],
-  "exclude": ["node_modules", "**/*.test.js", "**/*.spec.js"]
-} 
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "**/*.test.js", "**/*.spec.js", "dist/**/*"]
+}

package/tsup.config.js

@@ -0,0 +1,38 @@
+import { defineConfig } from 'tsup'
+
+export default defineConfig([
+  // ESM build
+  {
+    entry: 'src/**/*.js',
+    format: ['esm'],
+    outDir: 'dist/esm',
+    clean: true,
+    splitting: false,
+    sourcemap: false,
+    dts: false,
+    ignoreWatch: ['**/*.test.js', '**/*.spec.js'],
+  },
+  // CJS build
+  {
+    entry: 'src/**/*.js',
+    format: ['cjs'],
+    outDir: 'dist/cjs',
+    outExtension: () => ({ js: '.cjs' }),
+    clean: false,
+    splitting: false,
+    sourcemap: false,
+    dts: false,
+    ignoreWatch: ['**/*.test.js', '**/*.spec.js'],
+  },
+  // Types build
+  {
+    entry: 'src/**/*.js',
+    dts: {
+      only: true,
+    },
+    outDir: 'dist/types',
+    outExtension: () => ({ dts: '.d.cts' }),
+    clean: false,
+    ignoreWatch: ['**/*.test.js', '**/*.spec.js'],
+  },
+])

package/tsup.config.mjs

@@ -0,0 +1,43 @@
+import { glob } from 'glob'
+import { defineConfig } from 'tsup'
+
+function getEntryPoints() {
+  // Get all JS files except test files
+  return glob.sync('src/**/*.js', {
+    ignore: ['**/*.test.js', '**/*.spec.js'],
+  })
+}
+
+export default defineConfig([
+  // ESM build
+  {
+    entry: getEntryPoints(),
+    format: ['esm'],
+    outDir: 'dist/esm',
+    clean: true,
+    splitting: false,
+    sourcemap: false,
+    dts: false,
+  },
+  // CJS build
+  {
+    entry: getEntryPoints(),
+    format: ['cjs'],
+    outDir: 'dist/cjs',
+    outExtension: () => ({ js: '.cjs' }),
+    clean: false,
+    splitting: false,
+    sourcemap: false,
+    dts: false,
+  },
+  // Types build
+  {
+    entry: getEntryPoints(),
+    dts: {
+      only: true,
+    },
+    outDir: 'dist/types',
+    outExtension: () => ({ dts: '.d.cts' }),
+    clean: false,
+  },
+])