@splendidlabz/utils 1.5.1 → 1.6.0

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # @splendidlabz/utils
 
+## 1.6.0
+
+### Minor Changes
+
+- Many many upgrades which I didn't document properly 😅. The details are in Github history, but too many details to talk about now.
+
 ## 1.5.1
 
 ### Patch Changes

package/dist/dom/cookie.d.ts

@@ -1,11 +1,5 @@
-/**
- * Gets a cookie by name
- * Thanks to https://stackoverflow.com/a/21125098
- * @param {string} name Cookie name
- * @returns string Cookie value
- */
-export function getCookie(name: string): string;
+export function getCookie(name: any): any;
 export namespace cookies {
-    function get(name: any): string;
+    function get(name: any): any;
     function set(name: any, value: any, days: any): void;
 }

package/dist/dom/random-string.d.ts

@@ -3,5 +3,5 @@
  * Ensures first character is a letter so it can be used in HTML ids and classes
  * This can actually be used everywhere, not just in the browser.
  */
-export function randomString(length: any): string;
+export function randomString(length?: number): string;
 export function uuid(): `${string}-${string}-${string}-${string}-${string}`;

package/dist/lib/checks.d.ts

@@ -27,3 +27,4 @@ export function isArray(x: unknown): boolean;
  * notObject({}) // false
  */
 export function notObject(x: unknown): boolean;
+export function getType(x: any): "object" | "string" | "integer" | "float" | "boolean" | "function" | "undefined" | "symbol" | "bigint" | "array" | "unknown";

package/dist/lib/hash.d.ts

@@ -0,0 +1 @@
+export function isHashedValue(value: any, type?: string): boolean;

package/dist/lib/index.d.ts

@@ -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/dist/lib/objects/equal.d.ts

@@ -1,2 +1,2 @@
-export function isEqual(a: any, b: any): any;
+export function isEqual(a: any, b: any): boolean;
 export function notEqual(a: any, b: any): boolean;

package/dist/lib/objects/split.d.ts

@@ -7,4 +7,6 @@
 export function splitObject(obj: any, keys: any[]): {
     picked: {};
     omitted: any;
+    p: {};
+    o: any;
 };

package/dist/lib/strings/index.d.ts

@@ -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/dist/lib/strings/name.d.ts

@@ -0,0 +1,5 @@
+export function parseFullName(name: any): {
+    firstName: any;
+    middleName: any;
+    lastName: any;
+};

package/dist/node/random-string.d.ts

@@ -1,2 +1 @@
-export function randomString(length?: number): Promise<string>;
-export function randomStringSync(length?: number): string;
+export function randomString(length?: number): string;

package/dom/cookie.js

@@ -8,15 +8,16 @@ export const cookies = {
   },
 }
 
-/**
- * Gets a cookie by name
- * Thanks to https://stackoverflow.com/a/21125098
- * @param {string} name Cookie name
- * @returns string Cookie value
- */
 export function getCookie(name) {
   const match = document.cookie.match(new RegExp('(^| )' + name + '=([^;]+)'))
-  if (match) return match[2]
+  if (!match) return null
+  const decoded = decodeURIComponent(match[2])
+
+  try {
+    return JSON.parse(decoded)
+  } catch (e) {
+    return decoded
+  }
 }
 
 // By Copilot. Needs testing before confirmation.

package/dom/random-string.js

@@ -3,7 +3,7 @@
  * Ensures first character is a letter so it can be used in HTML ids and classes
  * This can actually be used everywhere, not just in the browser.
  */
-export function randomString(length) {
+export function randomString(length = 10) {
   const firstLetter = String.fromCharCode(65 + Math.floor(Math.random() * 26))
   const others = Math.random()
     .toString(36)

package/dom/random-string.test.js

@@ -0,0 +1,13 @@
+import { describe, expect, it } from 'vitest'
+import { randomString } from './random-string.js'
+
+describe('randomString', () => {
+  it('should generate a random string', () => {
+    const str = randomString()
+    expect(str).toBeDefined()
+    expect(str.length).toBe(10)
+
+    // Ensure the first character is a letter
+    expect(str[0]).toMatch(/[a-zA-Z]/)
+  })
+})

package/lib/checks.js

@@ -35,3 +35,19 @@ export function isArray(x) {
 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/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/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/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/objects/mix/mix.test.js

@@ -338,3 +338,11 @@ 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)
+})

package/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/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/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/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/node/random-string.js

@@ -1,10 +1,10 @@
-// For Node only
 import crypto from 'node:crypto'
 
-export async function randomString(length = 32) {
-  return crypto.randomBytes(length).toString('base64')
-}
+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
 
-export function randomStringSync(length = 32) {
-  return crypto.randomBytes(length).toString('hex')
+  return crypto.randomBytes(bytesNeeded).toString('base64').slice(0, length)
 }

package/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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@splendidlabz/utils",
-  "version": "1.5.1",
+  "version": "1.6.0",
   "description": "",
   "type": "module",
   "sideEffects": false,
@@ -51,7 +51,7 @@
     "statuses": "^2.0.1"
   },
   "devDependencies": {
-    "@splendidlabz/eslint-config": "2.0.0",
+    "@splendidlabz/eslint-config": "2.1.0",
     "jsdom": "^26.0.0",
     "np": "^10.2.0",
     "typescript": "^5.4.2",