@splendidlabz/utils 1.3.0

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

@@ -0,0 +1,86 @@
+// ========================
+// 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/lib/strings/convert-case/convert-case.md

@@ -0,0 +1,44 @@
+# 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/lib/strings/convert-case/convert-case.test.js

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

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

package/lib/strings/markdown.js

@@ -0,0 +1,39 @@
+/**
+ * Removes leading whitespaces from a Markdown content so they can be rendered appropriately.
+ * @param {string} content - The content to treat
+ * @param {Boolean} options.inline - Whether content is inline, not block
+ * @returns
+ */
+export function treatMarkdownWhitespace(
+  content,
+  { inline, isSlot = false } = {},
+) {
+  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/lib/strings/pluralize.js

@@ -0,0 +1,2 @@
+import pluralize from 'pluralize'
+export { pluralize }

package/lib/strings/query-string.js

@@ -0,0 +1,18 @@
+/**
+ * Converts object into a query string
+ * @param {Object} object
+ * @returns
+ */
+export function toQueryString(object) {
+  const searchParams = new URLSearchParams(object)
+  return searchParams.toString()
+}
+
+export function plural(count, noun, suffix = 's') {
+  console.warn('plural is deprecated. Use pluralize instead')
+  return `${count} ${noun}${count !== 1 ? suffix : ''}`
+}
+
+export function stripNumbers(string) {
+  return string.replace(/\d*/, '')
+}

package/lib/style/index.js

@@ -0,0 +1,11 @@
+import { toKebab } from '../strings/convert-case/convert-case.js'
+
+export function toStyleString(style) {
+  return Object.entries(style)
+    .map(([k, v]) => {
+      if (k.startsWith('--')) return `${k}:${v}`
+      else return `${toKebab(k)}:${v}`
+    })
+    .join('; ')
+    .concat(';')
+}

package/lib/symbols/index.js

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

package/lib/symbols/symbols.js

@@ -0,0 +1,9 @@
+export function getSymbol(object, description) {
+  return Object.getOwnPropertySymbols(object).find(
+    s => s.description === description,
+  )
+}
+
+export function getSymbolValue(object, description) {
+  return object[getSymbol(object, description)]
+}

package/node/common.js

@@ -0,0 +1,5 @@
+import crypto from 'crypto'
+
+export function uuid() {
+  return crypto.randomUUID()
+}

package/node/dirname.js

@@ -0,0 +1,17 @@
+import { fileURLToPath } from 'node:url'
+import path from 'path'
+
+/**
+ * Returns __dirname
+ * @param url — import.meta.url
+ * @returns
+ */
+export function __dirname(url) {
+  if (!url) throw Error("Please provide 'import.meta.url' to dirname")
+  return path.dirname(fileURLToPath(url))
+}
+
+// Just an alias
+export function dirname(url) {
+  return __dirname(url)
+}

package/node/file-cache.js

@@ -0,0 +1,135 @@
+import fs from 'fs/promises'
+import glob from 'glob-promise'
+import path from 'node:path'
+import { sort } from '../lib/arrays/index.js'
+
+// Newer and nicer API
+export async function createCache(dir) {
+  const absDirpath = path.join(process.cwd(), dir)
+  await fs.mkdir(absDirpath, { recursive: true })
+
+  return {
+    async cacheAt(file) {
+      if (file) {
+        // Return the cached file's modified timestamp
+        const absFilepath = path.join(absDirpath, file)
+        try {
+          const stat = await fs.stat(absFilepath)
+          return stat.mtimeMs
+        } catch (error) {
+          return 0
+        }
+      } else {
+        // Return the last modified timestamp of the cache directory
+        return getLastModifiedTime(dir + '/**/*')
+      }
+    },
+
+    getAbsPath(file) {
+      return path.join(absDirpath, file)
+    },
+
+    async hasFile(file) {
+      const absFilepath = path.join(absDirpath, file)
+      try {
+        await fs.stat(absFilepath)
+        return true
+      } catch (e) {
+        return false
+      }
+    },
+
+    async loadFile(file) {
+      try {
+        const absFilepath = path.join(absDirpath, file)
+        return fs.readFile(absFilepath)
+      } catch (error) {
+        console.warn(`File not found: ${file}`)
+      }
+    },
+
+    async saveFile(file, data) {
+      const absfilepath = path.join(absDirpath, file)
+      await fs.writeFile(absfilepath, data)
+    },
+
+    async loadJSON(file) {
+      const data = await this.loadFile(file)
+      try {
+        return JSON.parse(data)
+      } catch (err) {
+        console.warn(`Error parsing JSON: ${file}`)
+        return {}
+      }
+    },
+
+    async saveJSON(file, data) {
+      await this.saveFile(file, JSON.stringify(data))
+    },
+  }
+}
+
+// Legacy, not so nice API
+export async function fileCache({ dir, file }) {
+  // Makes the path if it doesn't exist
+  await fs.mkdir(path.join(process.cwd(), dir), { recursive: true })
+  const cachePath = path.join(process.cwd(), dir, `${file}`)
+
+  let modifiedAt = 0
+
+  try {
+    const stat = await fs.stat(cachePath)
+    modifiedAt = stat.mtimeMs
+  } catch (error) {} // Silent error
+
+  return {
+    modifiedAt,
+
+    async load() {
+      return fs.readFile(cachePath)
+    },
+
+    async save(data) {
+      await fs.writeFile(cachePath, data)
+    },
+
+    async loadJSON() {
+      return JSON.parse(await fs.readFile(cachePath))
+    },
+    async saveJSON(data) {
+      await fs.writeFile(cachePath, JSON.stringify(data))
+    },
+  }
+}
+
+export async function getLastModifiedTime(globPath) {
+  let files
+
+  if (typeof globPath === 'string') {
+    files = await glob(removeFirstSlash(globPath))
+  }
+
+  if (Array.isArray(globPath)) {
+    const a = await Promise.all(
+      globPath.map(path => glob(removeFirstSlash(path))),
+    )
+    files = a.flat()
+  }
+
+  files = await Promise.all(files.map(fs.stat))
+  files = files.map(file => file.mtimeMs)
+
+  const sorted = sort(files, { sortBy: 'mtimeMs', order: 'desc' })
+  return sorted[0] || 0
+}
+
+export async function getLatestModifiedTime(globPath) {
+  console.warn(
+    '`getLatestModifiedTime` has been renamed to `getLastModifiedTime` and will be deprecated in future versions. Please use `getLastModifiedTime` instead.',
+  )
+  return getLastModifiedTime(globPath)
+}
+
+export function removeFirstSlash(x) {
+  return x.startsWith('/') ? x.slice(1) : x
+}

package/node/file.js

@@ -0,0 +1,13 @@
+// Common FS stuff
+import fs from 'node:fs/promises'
+import path from 'node:path'
+
+export async function mkdir(path) {
+  return fs.mkdir(path, { recursive: true })
+}
+
+export async function copyFile(from, to) {
+  const dir = path.dirname(to)
+  await mkdir(dir)
+  await fs.copyFile(from, to)
+}

package/node/hash.js

@@ -0,0 +1,5 @@
+import crypto from 'node:crypto'
+
+export function sha256Hash(string) {
+  return crypto.createHash('sha256').update(string).digest('hex')
+}

package/node/index.js

@@ -0,0 +1,6 @@
+export * from './common.js'
+export * from './dirname.js'
+export * from './file-cache.js'
+export * from './hash.js'
+export * from './pkce.js'
+export * from './random-string.js'

package/node/pkce.js

@@ -0,0 +1,33 @@
+// For Node only.
+// Check the utils version for browsers.
+import crypto from 'node:crypto'
+import { randomString } from './random-string.js'
+
+export async function PKCE() {
+  const codeVerifier = await randomString()
+  const codeChallenge = await getCodeChallenge(codeVerifier)
+
+  return {
+    state: await randomString(),
+    code_verifier: codeVerifier,
+    code_challenge: codeChallenge,
+    code_challenge_method: 'S256',
+  }
+}
+
+/**
+ * Generates code challenge in node
+ * @param {string} verifier
+ * @returns string
+ */
+async function getCodeChallenge(verifier) {
+  // Hash to code verifier with SHA-256
+  const hash = crypto.createHash('sha256').update(verifier).digest()
+
+  // // Base64url encode the hash
+  return hash
+    .toString('base64')
+    .replace(/\+/g, '-')
+    .replace(/\//g, '_')
+    .replace(/=/g, '')
+}

package/node/random-string.js

@@ -0,0 +1,10 @@
+// For Node only
+import crypto from 'node:crypto'
+
+export async function randomString(length = 32) {
+  return crypto.randomBytes(length).toString('base64')
+}
+
+export function randomStringSync(length = 32) {
+  return crypto.randomBytes(length).toString('hex')
+}

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "@splendidlabz/utils",
+  "version": "1.3.0",
+  "description": "",
+  "type": "module",
+  "sideEffects": false,
+  "exports": {
+    ".": "./lib/index.js",
+    "./lib/*": "./lib/*.js",
+    "./dom": "./dom/index.js",
+    "./dom/*": "./dom/*.js",
+    "./actions": "./actions/index.js",
+    "./actions/*": "./actions/*.js",
+    "./node": "./node/index.js",
+    "./node/*": "./node/*.js"
+  },
+  "scripts": {
+    "lint": "eslint . --fix",
+    "test": "vitest run",
+    "test:watch": "vitest"
+  },
+  "author": "Zell Liew <zellwk@gmail.com>",
+  "dependencies": {
+    "dompurify": "^3.1.6",
+    "glob-promise": "^6.0.5",
+    "pluralize": "^8.0.0",
+    "statuses": "^2.0.1"
+  },
+  "devDependencies": {
+    "@splendidlabz/eslint-config": "*",
+    "jsdom": "^24.0.0",
+    "np": "^8.0.4",
+    "vitest": "^1.4.0"
+  }
+}